java自定义类实现指定规则的排序：Comparator接口、Comparable接口、CompareTo（）、Compare（）

1、排序的基本步骤

• 实现方法一：不使用比较器，实现Comparable接口
  1、实现java.lang.Comparable接口
  2、重写compareTo(Object obj)方法，注意使用this(当前元素)和obj进行比较，单参数。
  3、重点是compareTo()这个方法的返回值，返回值很重要，就规定了排序的规则

• 实现方法二：使用比较器：实现Comparator接口
  1、实现比较器实现java.util.Comparator接口。
  2、实现compare(Object o1, Object o2)方法,制定比较规则
  3、经常要把这个Comparator这个比较器传递给需要的部分（如TreeSet的构造方法、Arrays.sort(排序的内容，比较器)）

注：Comparable和Comparator怎么选择呢？
1、当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。
2、如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。

• 注意： 一些常见的类已经实现了Comparable接口如：String、Integer、Date…能够直接排序
  

2、实例：对自定义类进行排序（自己指定比较规则）

• 自定义类想进行排序，需要实现Comparable接口，否则在排序的时候，会出现向下转型失败！（可以看源码，知道在map的put方法的时候）
  

2.1、方法一实现：

1、实现java.lang.Comparable接口
2、重写compareTo(Object obj)方法，注意使用this(当前元素)和obj进行比较
3、重点是compareTo()这个方法的返回值，返回值很重要，就规定了排序的规则

• 代码实现：
  先按照年龄升序，如果年龄一样的再按照姓名升序。

/*
先按照年龄升序，如果年龄一样的再按照姓名升序。
 */
public class TreeSetTest05 {
    public static void main(String[] args) {
        TreeSet<Vip> vips = new TreeSet<>();
        vips.add(new Vip("zhangsi", 20));
        vips.add(new Vip("zhangsan", 20));
        vips.add(new Vip("king", 18));
        vips.add(new Vip("soft", 17));
        for(Vip vip : vips){
            System.out.println(vip);
        }
    }
}
class Vip implements Comparable<Vip>{
    String name;
    int age;

    public Vip(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Vip{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    /*
    compareTo方法的返回值很重要：
        返回0表示相同，value会覆盖。
        返回>0，会继续在右子树上找。【10 - 9 = 1 ，1 > 0的说明左边这个数字比较大。所以在右子树上找。】
        返回<0，会继续在左子树上找。
     */
    @Override
    public int compareTo(Vip v) {
        // 写排序规则，按照什么进行比较。
        if(this.age == v.age){
            // 年龄相同时按照名字排序。
            // 姓名是String类型，可以直接比。调用compareTo来完成比较。
            return this.name.compareTo(v.name);
        } else {
            // 年龄不一样
            return this.age - v.age;
        }
    }

2.2 方法二实现：

• 步骤：使用比较器：实现Comparator接口
  1、实现比较器实现java.util.Comparator接口。
  2、实现compare(Object o1, Object o2)方法,制定比较规则
  3、经常要把这个Comparator这个比较器传递给需要的部分（如TreeSet的构造方法、Arrays.sort(排序的内容，比较器)）

• 乌龟的年龄进行比较举例

import java.util.Comparator;
import java.util.TreeSet;
/*
TreeSet集合中元素可排序的第二种方式：使用比较器的方式。
最终的结论：
    放到TreeSet或者TreeMap集合key部分的元素要想做到排序,包括两种方式：
        第一种：放在集合中的元素实现java.lang.Comparable接口。
        第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。
Comparable和Comparator怎么选择呢？
    当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。
    如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。

    Comparator接口的设计符合OCP原则。
 */
public class TreeSetTest06 {
    public static void main(String[] args) {
        // 创建TreeSet集合的时候，需要使用这个比较器。
        // TreeSet wuGuis = new TreeSet<>();//这样不行，没有通过构造方法传递一个比较器进去。

        // 给构造方法传递一个比较器。
        //TreeSet wuGuis = new TreeSet<>(new WuGuiComparator());

        // 大家可以使用匿名内部类的方式（这个类没有名字。直接new接口。）
        TreeSet<WuGui> wuGuis = new TreeSet<>(new Comparator<WuGui>() {
            @Override
            public int compare(WuGui o1, WuGui o2) {
                return o1.age - o2.age;
            }
        });

        wuGuis.add(new WuGui(1000));
        wuGuis.add(new WuGui(800));
        wuGuis.add(new WuGui(810));

        for(WuGui wuGui : wuGuis){
            System.out.println(wuGui);
        }
    }
}

// 乌龟
class WuGui{
    int age;
    public WuGui(int age){
        this.age = age;
    }
    @Override
    public String toString() {
        return "小乌龟[" +
                "age=" + age +
                ']';
    }
}
// 单独在这里编写一个比较器
// 比较器实现java.util.Comparator接口。（Comparable是java.lang包下的。Comparator是java.util包下的。）
/*
class WuGuiComparator implements Comparator {
    @Override
    public int compare(WuGui o1, WuGui o2) {
        // 指定比较规则
        // 按照年龄排序
        return o1.age - o2.age;
    }
}
 */

• 二维数组的排序举例

int[][] people = {{7,0},{4,4},{7,1},{5,0},{6,1},{5,2}};
Arrays.sort(people, new Comparator<int[]>() {
    public int compare(int[] o1, int[] o2) {
        if (o1[0] == o2[0]) return o1[1] - o2[1];//如果想让h相同k小的站前面,多这一行！
        return o2[0]-o1[0];//o1本来就已经是数组中的每个元素，再o1[]就是该元素内部的东西再指定一次
    }
});

//输出
for(int[] data : people){
     System.out.println(Arrays.toString(data));
 }

输出结果：
[7, 0]
[7, 1]
[6, 1]
[5, 0]
[5, 2]
[4, 4]

3. 注意事项

3.1 基本数据类型只能直接排序，不可以自定义排序规则（可以使用stream流操作）

1. 注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）而要使用它们对应的包装类，比如下面这样就会报错。把数组改为Integer[] ints = new Integer[]{12, 4, 6, 7, 2, 8, 3, 9}; ，这样的数据就不会报错。
2. 注意的是，int是基本数据类型，而int[] 不是基本数据类型！！！所以在使用map集合等等泛型中，int[]直接写就好，不能写Integer[].
   
3. Arrays.sort() 默认是实现升序，想要改为降序，Arrays.sort(排序数组, Collections.reverseOrder()); 这样处理就可以了。
4. 查看源码就知道重载的数据类型包括 Object 一共有八个,其他七个就是基本类型: int , long , short , char , byte , float , double，对于自定义的类型肯定是要自己指定比较规则的，对于基本数据类型，默认有实现。

3.2 使用stream流将基本数据类型也实现自定义的排序

	int nums = {1,-5,-4,36,5,-9,4,-8,15};
    	// 将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
	nums = IntStream.of(nums) //IntStream是一种特殊的Stream，用来提供对int类型数据进行相关的stream操作
		     .boxed() //装箱，变为Stream
		     .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1)) //操作封装的数据类型。使用lambda表达式
		     .mapToInt(Integer::intValue)//返回一个 IntStream，其中包含将给定函数应用于此流的元素的结果。
		     .toArray(); //IntStream转为数组

3.3接上面的第一个点。将 int[] 转成 Integer[]

这里使用java8的stream来进行转化，详细步骤如下所示：

//初始化int数组
int[] nums = {1,2,3,4,5,6};
//将int数组转换为数值流
IntStream stream = Arrays.stream(nums);
//流中的元素全部装箱，转换为Integer流 
Stream<Integer> integerStream = stream.boxed();
//将流转换为数组
Integer[] integers = integerStream.toArray(Integer[]::new);

上面是分解步骤，实际应用中一行代码即可解决

Integer newNums[] = Arrays.stream(nums).boxed().toArray(Integer[]::new);