11.Collections工具类

目录

11.Collections工具类

11.1.Collections中常用方法

11.2.sort方法的使用

---

11.Collections工具类

11.1.Collections中常用方法

11.2.sort方法的使用

 1.java.util.Collections是集合工具类，用来对集合进行操作的，部分方法如下：静态方法直接调用。

 *   public static<T> boolean addAll(Collection<T> c,T...elements):
     往集合添加一些元素将参数列表elements中元素都添加到集合c中。
 *   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>):将集合元素排序

  2.sort方法sort(List<T>list)这个排序使用前提(规则)：
     被排序的集合里面存储的元素，必须实现Comparable接口,重写接口中方法compareTo来定义排序规则。
     比如：List集合中元素为String类型，而String已经重写了compareTo方法。若集合存储元素为自定义的Person类型，那么在Person类中需要重写compareTo方法。

  3.Comparable接口的排序规则：
      自己(this)-参数:表示升序，如this.getAge()-o.getAge()

  4.sort(List<T> list,Comparator<? super T>)这个排序方法的使用规则:
      通过匿名内部类重写Comparator接口中的Compare方法。不管是不是自定义类型都要重写。

Collections.sort(list04, new Comparator<Integer>() {//匿名内部类
            @Override
            public int compare(Integer o1, Integer o2) {
                 //重写比较的规则
                 return o1-o2;  //表示升序
             }
         });

  5.Comparator的排序规则：o1-o2为升序

  6.sort(List<T> list,Comparator<? super T>)这个方法中的Comparator接口与sort(List<T>list)方法中要实现的Comparable接口的区别：
      Comparable:自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写compareTo方法
      Comparator:是一个接口，相当于找一个第三方的裁判，比较两个

public class Demo1_Collections {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();

        /*往集合添加多个元素，一个个添加比较麻烦，Collections集合工具类提供批量添加的方法
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        */

        /**
         *public static<T> boolean addAll(Collection<T> c,T...elements):往集合添加一些元素
         */

        Collections.addAll(list,"a","b","c","d");
        System.out.println(list);//[a,b,c,d]list是有序集合

        /**
         * public static void shuffle(List<?>list):打乱集合顺序
         */

        Collections.shuffle(list);
        System.out.println(list);//[d, a, c, b]

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

        ArrayList<Integer> list01 = new ArrayList<>();//创建集合
        Collections.addAll(list01,1,3,2); //批量添加
        Collections.sort(list01);  //集合元素排序(默认升序)
        System.out.println(list01);//[1, 2, 3] //输出

        /**
         * 当自定义类型，定义Person类作为集合中元素的类型，使用sort排序Person类型的数据
         * 时需要Person类实现Comparable接口，并重写compareTo方法来定义排序规则。
         * 这里重定义comparaTo方法规则是根据年龄升序排序return this.getAge()-o.getAge();
         */

        ArrayList<Person> list03 = new ArrayList<>();
        //用Collections集合工具类批量加入多个匿名对象。
        Collections.addAll(list03,new Person("zhangsan",18),
                                  new Person("lisi",30),
                                  new Person("wangwu",25));
        //Person类实现Comparable接口，并重写compareTo方法定义排序规则按照年龄升序
        Collections.sort(list03);
        System.out.println(list03);

        /**
         * public static <T> void sort(List<T> list,Comparator<? super T>):将集合元素排序
         */

        ArrayList<Integer> list04 = new ArrayList<>();
        Collections.addAll(list04,1,3,2);
        System.out.println(list04);//[1,3,2]有序
        Collections.sort(list04, new Comparator<Integer>() {//匿名内部类
            @Override
            public int compare(Integer o1, Integer o2) {
                //重写比较的规则
                return o1-o2;  //表示升序
            }
        });

        //下面是自定义类型Student使用sort(List<T> list,Comparator<? super T>)排序方法
        ArrayList<Student> list05 = new ArrayList<>();
        Collections.addAll(list05,new Student("陈雨",1),
                                  new Student("王五",1),
                                  new Student("阿哥",1)
                           );
        Collections.sort(list05, new Comparator<Student>() {//匿名类中重写compare
            @Override
            public int compare(Student o1, Student o2) {
                //重写compare方法，自定义排序规则，按年龄升序,年龄同则按名字的第一个字比较
                int result= o1.getAge()-o2.getAge();
                if(result==0){//若年龄一样(0表示一样)
                    result=o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list05);
    }
}

 

/**
 * 定义Person类作为集合中元素的类型，在Demo1_Collections类中使用
 * sort(List<T>list)排序Person类型的数据时需要Person类型实现
 * Comparable接口，并重写compareTo方法来定义排序规则。
 */
public class Person implements Comparable<Person>{
    //Person类要实现Comparable接口，泛型与集合中元素类型一致即Person类型
    private String name;
    private int age;

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

    public Person() {
    }

    /**
     * 重写toString方法用来输出Person类中的属性。
     * 当输出元素为Person类型集合时，就是输出集合中每一个对象的name和age属性值，
     * 因为println底层就是toString方法，现在重写了toString方法了。
     * @return
     */
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /**
     *Person类实现Comparable接口后，重写compareTo方法，定义排序规则
     * @param o
     * @return
     */
    @Override
    public int compareTo(Person o) {
      //  return 0;//返回0，认为元素都是相同的
        //自定义比较规则：比较两个人的年龄(this,参数Person)
        //this表示调用该方法的对象，o表示参数参数传递来进行比较的对象
        //Comparable接口排序规则：自己(this)-参数：表示升序；反之。
        return this.getAge()-o.getAge();
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

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

 

/**
 *定义Student类作为集合中元素的类型，在Demo1_Collections类中使用
 *sort(List<T> list,Comparator<? super T>)排序Student类型的数据
 * 时需要Person类型实现Comparable接口，并重写compareTo方法来定义排序规则。
 */
public class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

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

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

 */