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[].
    java自定义类实现指定规则的排序:Comparator接口、Comparable接口、CompareTo()、Compare()_第1张图片
  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);

你可能感兴趣的:(JavaSE,java,jvm,开发语言)