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;
     }
 }