Collections集合工具类 Comparator，Comparable

常⽤功能

java.utils.Collections 是集合⼯具类，⽤来对集合进⾏操作。部分⽅法如下：
public static boolean addAll(Collection c, T… elements) ：往集合中添加
⼀些元素。
public static void shuffle(List<?> list) ：打乱集合顺序。
public static void sort(List list) ：将集合中元素按照默认规则排序。
public static void sort(List list，Comparator<? super T> ) ：将集合中元
素按照指定规则排序。

public class CollectionsDemo {
 public static void main(String[] args) {
 ArrayList<Integer> list = new ArrayList<Integer>();
 // 原来写法
 // list.add(12);
 // list.add(14);
 // list.add(15);
 // list.add(1000);
 // 采⽤⼯具类完成 往集合中添加元素 
 Collections.addAll(list, 5, 222, 1，2);
 System.out.println(list);
 // 将集合中元素按照默认规则排序。
 Collections.sort(list);
 System.out.println(list);
 }
}
/*结果：
[5, 222, 1, 2] [1, 2, 5, 222]
*/

Comparable 自然排序

comparable 接口实际上是出自java.lang包 它有一个 compareTo(Object obj)方法用来排序

案例 重写compareTo(Object obj) 完成根据User 的age 大小排序

如果想要集合中的元素完成排序，那么必须要实现⽐较器 Comparable 接⼝

import java.util.Objects;

public class User implements Comparable<User> {
    private int age;
    private String name;

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

    public User() {
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }

    @Override
    public int compareTo(User o) {
             // 正序 this.age-o.age
            // 降序 o.age-this.age;
            return o.age-this.age;
            
    }
}

import java.util.TreeSet;
/*TreeSet 中序遍历 默认从小到大排序*/
public class CompareToDemo{
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(8);
        treeSet.add(7);
        treeSet.add(11);
        treeSet.add(4);
        System.out.println(treeSet);

       // 如果没有Comparable接口则显示ClassCastException 类型转换异常
       // 根据User 的 age 从到小排序
        TreeSet<User> ts=new TreeSet<>();
        User user = new User(18,"A");
        User user1 = new User(20,"B");
        User user2= new User(16,"C");
        User user3 = new User(17,"D");
        ts.add(user);
        ts.add(user1);
        ts.add(user2);
        ts.add(user3);
        System.out.println(ts);
    }
    /*输出结果
    [4, 7, 8, 11]
    [User{age=20, name='B'}, User{age=18, name='A'}, User{age=17, name='D'}, User{age=16, name='C'}]*/
}

Comparator⽐较器(自定义比较器)

public static void sort(List list，Comparator<? super T> )
comparator接口实际上是出自 java.util 包它有一个compare(Object obj1, Object obj2)方法用来排序

案例 重写Comparator 的compare(Object o1 ,Object 02)

数组: Arrays.sort(new Comparator)
List: Collections.sort(new Comparator)
Set: TreeSet(new Comparator)
Map: TreeMap(new Comparator)

import java.util.*;
/*
 * 数组排序 Arrays.sort
 * List排序  Collections.sort
 *  Set排序  TreeSet
 * Map 排序   TreeMap*/
public class SortCompare {
    public static void main(String[] args) {
        //不能使用基本数据类型 Arrays.sort(new Comparator)
        Integer[] arr = new Integer[]{1, 2, 5, 3, 0,};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            //重写compare方法
            public int compare(Integer o1, Integer o2) {
                //降序
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(arr));
        //Collections.sort(new Comparator)
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(4);
        list.add(3);
        list.add(2);
        //重写Collections.sort 
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
                //o2-o1 倒序
                //o1-o2 正序
            }
        });
        System.out.println(list);
        //TreeSet(new Comparator)
        TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {
            @Override
            //自定义排序
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        treeSet.add(8);
        treeSet.add(7);
        treeSet.add(11);
        treeSet.add(4);
        System.out.println(treeSet);
        // Map: TreeMap(new Comparator)
       TreeMap<Integer, String> map = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        map.put(1,"A");
        map.put(3,"A");
        map.put(0,"A");
        map.put(8,"A");
        System.out.println(map);
    }


}

简述Comparable和Comparator两个接⼝的区别

Comparable 可以认为是一个内比较器,实现了Comparable接口类有一个特点 ,就是可以和自己比较。至于具体和另一个实现Comparable接口的类如何比较,则依赖compareTo(Obj o)方法的实现，compareTo方法也被称为自然比较方法。
如果一个Collection的对象想要Collections的sort方法自动进行排序的话，那么这个对象必须实现Comparable接口。compareTo方法的返回值是int，有三种情况：
1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数
2、比较者等于被比较者，那么返回0
3、比较者小于被比较者，那么返回负整数
Comparator
omparator可以认为是是一个外比较器，Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：
1、o1大于o2，返回正整数
2、o1等于o2，返回0
3、o1小于o3，返回负整数