Java 比较器 Comparator 使用 / 获取最大最小值

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法 被称为它的自然比较方法。只能在类中实现 compareTo() 一次，不能经常修改类的代码实现自己想要的排序。实现 此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序，对象可以用作有序映射中 的键或有序集合中的元素，无需指定比较器。

Comparator：强行对某个对象进行整体排序。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set 或 有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

Comparator 使用

        ArrayList<Integer> list = new ArrayList<Integer>();
// 采用工具类 完成 往集合中添加元素
        Collections.addAll(list, 5, 222, 1, 2);
// 排序方法
        Collections.sort(list);
//        输出排序后值 第一个最小 末位最大
        System.out.println(list);//[1, 2, 5, 222]

// 为对象排序
        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("cba");
        list1.add("abc");
        list1.add("bca");
        Collections.sort(list1, new Comparator<String>() {
            @Override
//            第一个参数代表较小的 第二个较大
            public int compare(String o1, String o2) {return o1.charAt(0) - o2.charAt(0);
            }
        });
//        Lamada 改写
        Collections.sort(list1, (o1, o2) -> o1.charAt(0) - o2.charAt(0));
        Collections.sort(list1, Comparator.comparingInt(o -> o.charAt(0)));
        System.out.println(list1);//[abc, bca, cba]

Comparable 使用

Student 实体类

import lombok.AllArgsConstructor;
import lombok.Data;
@Data
@AllArgsConstructor
public class Student implements Comparable<Student> {
    private String name;
    private int age;

    @Override
    public int compareTo(Student o) {return this.age - o.age;// 升序}
}

或者用 if 判断重写

    @Override
    public int compareTo(Student o) {
    // 升序
        if (this.age > o.age) {return 1;} else if (this.age < o.age){return -1;} else{return 0;}
    }

测试

// 创建四个学生对象 存储到集合中
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(new Student("rose", 18));
        list.add(new Student("jack", 16));
        list.add(new Student("mark", 16));
        list.add(new Student("mona", 20));
/*
让学生 按照年龄排序 升序
*/
        Collections.sort(list);// 要求 该 list 中元素类型 必须实现比较器 Comparable 接口
        for (Student student : list) {System.out.println(student);
        }

stream 获取最大 / 小值

ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 2, 5, 3, 8, 7, 9);
Integer max = list.stream().max(Integer::compare).get();
Integer min = list.stream().min(Integer::compare).get();
System.out.println(" 最大 " + max + ", 最小 " + min); // 最大 9, 最小 2 

针对与于对象，例如上述 Student 获取最大年龄跟最小年龄

ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("rose", 18));
list.add(new Student("jack", 16));
list.add(new Student("mark", 16));
list.add(new Student("bob", 27));
list.add(new Student("mona", 20));
Student max = list.stream().max(Student::compareTo).get();
Student min = list.stream().min(Student::compareTo).get();
System.out.println(max);
System.out.println(min);

但是如果没有继承 Comparable 接口重写 compareTo 的话，就得代码比较年龄了

        ArrayList<Student> list = new ArrayList<Student>();
        list.add(new Student("rose", 18));
        list.add(new Student("jack", 16));
        list.add(new Student("mark", 15));
        list.add(new Student("bob", 27));
        list.add(new Student("mona", 20));
//        取最大年龄 这里同样用 Comparator
        Student max = list.stream().max(new Comparator<Student>() {
            @Override
            public int compare(Student a, Student b) {if (a.getAge() > b.getAge()) {return 1;} else {return -1;}
            }
        }).get();
//        取最小年龄 取较大值中最小值 这里也可以用 max 不过就要将 > 改为 <
        Student min = list.stream().min((a, b) -> {if (a.getAge() > b.getAge()) {return 1;} else {return -1;}
        }).get();
//        Lamada 简写
        Student max1 = list.stream().max((a, b) -> a.getAge()-b.getAge()).get();
        Student max2 = list.stream().max(Comparator.comparingInt(Student::getAge)).get();
//        若跟参数 a b 顺序不对应的话无法简写成 comparingInt 但 max 这时就成取最小值；
        Student min1 = list.stream().max((a, b) -> b.getAge()-a.getAge()).get();
        Student min2 = list.stream().min((a, b) -> a.getAge()-b.getAge()).get();
        System.out.println(min);
        System.out.println(min1);
        System.out.println(min2);
        System.out.println(max);
        System.out.println(max1);
        System.out.println(max2);

对 double 等类型比较

在 Student 实体类中加入 Double hign 身高属性，直接调用 Comparator.comparingDouble 方法，或者直接使用 Comparator.comparing 也可以。

//        打印最高的学生
        Student studentMax = list.stream().max(Comparator.comparingDouble(Student::getHign)).get();
        Student studentMin = list.stream().min(Comparator.comparingDouble(Student::getHign)).get();
        System.out.println(studentMax);
        System.out.println(studentMin);
        Student studentMax1 = list.stream().max((a, b) -> {if (a.getHign() > b.getHign()) {return 1;} else {return -1;}
        }).get();
        Student studentMin1 = list.stream().min((a, b) -> {if (a.getHign() > b.getHign()) {return 1;} else {return -1;}
        }).get();
        System.out.println(studentMax1);
        System.out.println(studentMin1);
        Student studentMax2 = list.stream().max(Comparator.comparing(Student::getHign)).get();
        System.out.println(studentMax2);

当然了，也可以用 sort 进行排序，对于 double 也可以使用上述策略

//        年龄从低到高
        list.sort((a, b) -> a.getAge() - b.getAge());
        System.out.println(list);
//        身高升序
        list.sort(Comparator.comparing(Student::getHign));
        System.out.println(list);
//        身高降序 简而言之就是 o2.getHign()-o1.getHign()>0，但是 compare 方法只返回 int，强制类型转换会导致不精准
        list.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {if (o1.getHign() < o2.getHign()) {return 1;} else {return -1;}
            }
        });
        System.out.println(list);

stream 排序

用 sorted 即可

Stream<Student> asc = list.stream().sorted((a,b)->a.getAge()-b.getAge());
asc = list.stream().sorted(Comparator.comparingInt(Student::getAge));
Stream<Student> desc = list.stream().sorted((a,b)->b.getAge()-a.getAge());
System.out.println(asc.collect(Collectors.toList()));
System.out.println(desc.collect(Collectors.toList()));