14.2 Collections工具类、Comparator比较器(Comparable接口中的方法compareTo（）、Comparator接口中的compare（）方法)

目录

Collections是集合工具类

列：集合工具类中addAll（）、shuffle（）方法练习

Comparator比较器

列：基本类型的包装类排序

列：重写Comparable接口中的方法compareTo（）方法实现对象的排序

列：使用Comparator接口中的compare（）方法实现排序

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

---

Collections是集合工具类

• public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一 些元素。
• public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
• public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
• public static <T> void sort(List<T> list，Comparator<? super T> ) :将集合中元素按 照指定规则排序。

列：集合工具类中addAll（）、shuffle（）方法练习

   public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();

        Collections.addAll(coll, "赵", "钱", "孙", "李");//添加数据
        System.out.println("集合是："+coll);//集合是：[赵, 钱, 孙, 李]

        List list = (List) coll;
        //public static void shuffle(List<?> list)  shuffle由于List和其子类集合
        Collections.shuffle(list);
        System.out.println("打乱后的coll集合："+coll);//打乱后的coll集合：[赵, 李, 钱, 孙]
        System.out.println("打乱后的list集合："+list);//打乱后的list集合：[赵, 李, 钱, 孙]
    }

---

Comparator比较器

在JAVA中提供了两种比较实现的方式，一种是 比较死板的采用 java.lang.Comparable 接口去实现，一种是灵活的当我需要做排序的时候在去选择 的 java.util.Comparator 接口完成。

• public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
• public static <T> void sort(List<T> list，Comparator<? super T> ) :将集合中元素按 照指定规则排序。

列：基本类型的包装类排序

public class Demo02Sort {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(1);
        list.add(3);
        System.out.println(" 原集合：" + list);

        //1 public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
        Collections.sort(list);
        System.out.println("1 排序后的集合：" + list);       
    }
}

列：重写Comparable接口中的方法compareTo（）方法实现对象的排序

Person重写接口Comparable中的compareTo()方法

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

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //重写排序的规则
    //return this.getAge() - o.getAge();//年龄升序排序
    @Override
    public int compareTo(Person o) {
        return this.getAge()-o.getAge();//年龄升序排序
    }
}

 public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。

    public static void main(String[] args) {
        // 对象的排序  重写Comparable接口中的方法compareTo（）方法
        ArrayList<Person> perList = new ArrayList<>();
        perList.add(new Person("老赵",12));
        perList.add(new Person("老钱",10));
        perList.add(new Person("老孙",13));
        perList.add(new Person("老周",10));
        Collections.sort(perList);
        for (Person person : perList) {
            System.out.println(person);
        }
    }

列：使用Comparator接口中的compare（）方法实现排序

public class Student {
    private String name;
    private int age;

    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

public class Demo03Sort {
    public static void main(String[] args) {
        method01();
        method02();

    }

    //1 Integer集合比较
    private static void method01() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(2);
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(list);
    }

    //2 对象集合比较
    private static void method02() {
        ArrayList<Student> stList = new ArrayList<>();
        stList.add(new Student("老赵", 19));
        stList.add(new Student("老钱", 18));
        stList.add(new Student("老孙", 20));
        stList.add(new Student("老赵", 19));
        Collections.sort(stList, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();

/*                //按照年龄升序排序
                int result =  o1.getAge()-o2.getAge();
                //如果两个人年龄相同,再使用姓名的第一个字比较
                if(result==0){
                    result =  o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return  result;*/
            }
        });
        for (Student student : stList) {
            System.out.println(student);
        }
    }
}

结果：

 

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

接口	java.lang.Comparable	java.util.Comparator
使用前提：	类实现Comparable接口中的compareTo方法	多使用匿名内部类，实现Comparator接口中的compare方法
	自然排序：强行对实现它的每个类的对象进行整体排序	强行对某个对象进行整体排序
	基本类型的包装类排序Collections.sort(list) 对象排序: 类实现Comparable接口中的compareTo方法， 在进行排序Collections.sort(list)	对象排序 Collections.sort( list，Comparator<? super T> )