Collections集合工具类常用的方法

java.utils.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()方法

package _5Collections集合工具类;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @Author Admin
 * @Classname DemoCollections
 * @Package _5Collections集合工具类
 * @GreatDate 2020/04/19 17:29:01
 * @Description TODO 演示Collections集合工具类
 */
public class DemoCollectionsAddAll {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //往集合中添加元素
        list.add("0");
        list.add("b");
        list.add("c");
        list.add("x");
        list.add("x");
        list.add("u");
        list.add("K");
    
        System.out.println(list);//[0, b, c, x, x, u, K]
        /*
            public static <T> boolean addAll(Collection<T> c, T... elements);
                    往集合中添加一些元素[添加多个元素]。
         */
        Collections.addAll(list,"a","b","l");
        System.out.println(list);
        
    }
}

sort(List<T> list)方法,实现Comparable接口

public static <T> void sort(List<T> list);
              //将集合中元素按照默认规则排序。
注意：
  sort（List<T>List）使用前提
/*    被排序的集合里边存储的元素，必须实现comparable接口，
   因此覆写comparable接口中的方法 compareTo()，可以重新定义排序的规则。
*/
comparable 接口中的排序规则：
  自己（this）-参数：升序，反之，就是降序.

实例：

package _5Collections集合工具类;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @Author Admin
 * @Classname DemoCollectionsAddSort
 * @Package _5Collections集合工具类
 * @GreatDate 2020/04/19 19:32:10
 * @Description TODO 演示Collectionsl类的Sort()方法
 */
/*
    public static <T> void sort(List<T> list);
                    将集合中元素按照默认规则排序。
   注意：
        sort（List<T>List）使用前提
        被排序的集合里边存储的元素，必须实现comparable接口，
        因此覆写comparable接口中的方法compareTo()，可以重新定义排序的规则。
    comparable接口中的排序规则：
        自己（this）-参数：升序，反之，就是降序.
    
 */
public class DemoCollectionsComparableSort {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(6);
        list.add(8);
        list.add(5);
        System.out.println(list);//[1, 6, 8, 5]
        System.out.println("---------------------------");
        Collections.sort(list);//默认是升序
        System.out.println(list);
        System.out.println("---------------------------");
        ArrayList<String> list01 = new ArrayList<>();
        list01.add("b");
        list01.add("a");
        list01.add("c");
        list01.add("A");
        
        System.out.println(list01);//[b, a, c, A]
        System.out.println("---------------------------");
        Collections.sort(list01);//默认是升序
        System.out.println(list01);
        System.out.println("---------------------------");
        
        ArrayList<Person> list02 = new ArrayList<>();
        list02.add(new Person("张三", 29));
        list02.add(new Person("李四", 23));
        list02.add(new Person("王五", 19));
        list02.add(new Person("赵六", 28));
        System.out.println(list02);
        //排序前：[Person{name='张三', age=29}, Person{name='李四', age=23}, Person{name='王五', age=19}, Person{name='赵六', age=28}]
        System.out.println("---------------------------");
        Collections.sort(list02);
        System.out.println(list02);//升序
        //覆写comparable接口中的方法compareTo()后，
        //[Person{name='王五', age=19}, Person{name='李四', age=23}, Person{name='赵六', age=28}, Person{name='张三', age=29}]
    }
    
}

实体类：

package _5Collections集合工具类;

/**
 * @Author Admin
 * @Classname Person
 * @Package _2Set集合._3HashCode哈希值
 * @GreatDate 2020/04/19 09:13:54
 * @Description TODO 演示实体类
 */

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;
    }
    //覆写排序的规则
    @Override
    public int compareTo(Person o) {
        // return 0;//认为元素都是相同的
        //自定义比较的规则，如：比较两个人的年龄（this，参数Person）
    
        //return this.getAge() - o.getAge();//年龄升序排序
        return o.getAge() - this.getAge();//年龄降序序排序
    }
}

sort(List<T> list，Comparator<? super T>实现Comparator接口

public static <T> void sort(List<T> list，Comparator<? super T> );
             //将集合中元素按照指定规则排序
//Comparator接口中的排序规则：
//         o1 - o2 :升序排序，反之，就是降序排序

Comparator和Comparable两个接口的区别：

• Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法

• Comparator：相当于找一个第三方的裁判，比较两个。

package _5Collections集合工具类;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * @Author Admin
 * @Classname DemoCollectionCopartorSort
 * @Package _5Collections集合工具类
 * @GreatDate 2020/04/19 21:18:13
 * @Description TODO 第二种排序方法
 */
/*
    public static <T> void sort(List<T> list，Comparator<? super T> );
                    将集合中元素按照指定规则排序
    Comparator和Comparable两个接口的区别：
        Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
        Comparator：相当于找一个第三方的裁判，比较两个。
    Comparator接口中的排序规则：
        o1 - o2 :升序排序，反之，就是降序排序
 */
public class DemoCollectionCopartorSort {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(6);
        list.add(8);
        list.add(5);
        System.out.println(list);//[1, 6, 8, 5]
        
        Collections.sort(list, new Comparator<Integer>() {
            //覆写比较的规则
            @Override
            public int compare(Integer o1, Integer o2) {
                // return o1 - o2;//升序排序
                return o2 - o1;//降序排序
            }
        });
        System.out.println(list);
        System.out.println("------------------");
        
        ArrayList<Student> list1 = new ArrayList<>();
        list1.add(new Student("张三", 26));
        list1.add(new Student("李四", 28));
        list1.add(new Student("王五", 22));
        list1.add(new Student("赵六", 22));
        /*//一个规则
        Collections.sort(list1, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();//按照年龄的升序排序
            }
        });*/
        //多个规则；扩展，了解
        Collections.sort(list1, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照年龄的升序排序
                int result = o1.getAge() - o2.getAge();
                //如果两个人年龄相同，再使用姓名比较第一个字
                if (result == 0) {
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list1);
    }
}

 

实体类

package _5Collections集合工具类;

/**
 * @Author Admin
 * @Classname Student
 * @Package _5Collections集合工具类
 * @GreatDate 2020/04/19 21:56:29
 * @Description TODO
 */
public class Student {
    private String name;
    private int age;
    
    public Student() {
    }
    
    @Override
    public String toString() {
        return "Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
    }
    
    public Student(String name, int age) {
        this.name = name;
        this.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;
    }
}