注意：

  1. **o1-o2** 相等于 **o1.compareTo(o2)**
  2. compareTo 和 compare 比较规则一样
    • 如果返回 **1** 说明 o1 > o2
    • 如果返回 **0** 说明 o1 = o2
    • 如果返回 **-1** 说明 o1 < o2
  3. o1是数组前一个数，o2是数组后一个数
  4. 当 compare 方法的 返回值大于0 的时候就将数组的前一个数和后一个数做交换。

    下面二者等价： return o1-o2 ：o1 - o2 > 0 时候互换，前面大后面小则互换，大的在后面则升序 return o1.compareTo(o2)


下面二者等价： return o2-o1 ：o2 - o1 > 0 时候互换，后面大前面小则互换，大的在后面则降序 return o2.compareTo(o1)

Java 比较（==, equals, compareTo, compare)

== :

  1. 一般用来比较基本数据类型 (Primitive Type)，直接比较的是值（Value）是否相等。
  2. 当遇到两个引用类型比较时候，看是否是同一地址。

equals()： 

  1. public boolean equals (Object x){
  2.   if(this == x) return true;
  3.   ....
  4. }
  1. 一般用于引用类型的比较规则的重写，重写的句首仍使用 ==
  2. equals() 和 compareTo() 都是方法，不适用于基本数据类型。

compare()方法，方法返回值为 int 类型，比较两个值。

  • 如果返回 **1** 说明 o1 > o2
  • 如果返回 **0** 说明 o1 = o2
  • 如果返回 **-1** 说明 o1 < o2

compareTo() 方法返回值为 int 类型，比较两个值。如：o1.compareTo(o2) ，返回 1，0，-1

  • 如果返回 **1** 说明 o1 > o2 如 2>1
  • 如果返回 **0** 说明 o1 = o2 如 "cc"="cc"
  • 如果返回 **-1** 说明 o1 < o2 如 6<7

比较方法：

  1. 字符串与对象进行比较
  2. 按 字典顺序 比较两个字符串

比较过程：
先比较对应字符的大小(ASCII码顺序)

  • 如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值
  • 如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推
  • 直至得到最终结果或者其中一个参数结束

compare 升序

  1. // 升序
  2. public static void main(String[] args) {
  3.     Integer[] nums = new Integer[]{6, 8, 3, 0, 2};
  4.     Arrays.sort(nums, new Comparator<Integer>() {
  5.         @Override
  6.         public int compare(Integer o1, Integer o2) {
  7.             return o1 - o2;
  8.         }
  9.     });
  10. }

compare 降序

// 降序
public static void main(String[] args) {
    Integer[] nums = new Integer[]{6, 8, 3, 0, 2};
    Arrays.sort(nums, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });
}

通过源码可知，当 compare 方法的返回值大于0的时候就将数组的前一个数和后一个数做交换。

以升序为例来讲解，升序的话 compare 方法就 return o1 - o2，那么就是 return dest[j-1] - dest[j]

  • 当 dest[j-1] > dest[j] 时，就进行交换。
  • 当 dest[j-1] <= dest[j] 时位置不变，从而达到数组升序。

外部类

    //自定义能够实现升序的比较器
    class DescComparator implements Comparator<Map.Entry<String,Integer>>
    {
        @Override
        public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
            if (o1.getValue().equals(o2.getValue())){
                //字典序小的在前 所以 o1 比 o2
                return o2.getKey().compareTo(o1.getKey());
            }else {
                //数量小的在前所以 o1 - o2
                return o1.getValue() - o2.getValue();
            }
        }
    }

   //小根堆
   PriorityQueue queue = new PriorityQueue(k,compa);

匿名内部类

PriorityQueue<Map.Entry<String,Integer>> queue = new PriorityQueue<>(new Comparator<Map.Entry<String, Integer>>() {
    @Override
    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
        if (o1.getValue().equals(o2.getValue())){
            //字典序小的在前 所以 o1 比 o2
            return o2.getKey().compareTo(o1.getKey());
        }else {
            //数量小的在前所以 o1 - o2
            return o1.getValue() - o2.getValue();
        }
    }
});