Java 之 Collections 工具类

一、Collections 概述

　　java.utils.Collections 是集合工具类，用来对集合进行操作。

　   Collections 是一个操作 Set、List 和 Map 等集合的工具类。Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法：

二、常用方法

public static <T> boolean addAll(Collection<? super T> c,T... elements)将所有指定元素添加到指定 collection 中。
public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且必须是可比较大小的，即支持自然排序的。而且集合也事先必须是有序的，否则结果不确定。
public static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且集合也事先必须是按照c比较器规则进行排序过的，否则结果不确定。
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，而且支持自然排序
public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，按照比较器comp找出最大者
public static void reverse(List<?> list)反转指定列表List中元素的顺序。
public static void shuffle(List<?> list) List 集合元素进行随机排序，类似洗牌
public static <T extends Comparable<? super T>> void sort(List<T> list)根据元素的自然顺序对指定 List 集合元素按升序排序
public static <T> void sort(List<T> list,Comparator<? super T> c)根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
public static void swap(List<?> list,int i,int j)将指定 list 集合中的 i 处元素和 j 处元素进行交换
public static int frequency(Collection<?> c,Object o)返回指定集合中指定元素的出现次数
public static <T> void copy(List<? super T> dest,List<? extends T> src)将src中的内容复制到dest中
public static <T> boolean replaceAll(List<T> list，T oldVal，T newVal)：使用新值替换 List 对象的所有旧值
public static <T> List<T> synchronizedList(List<T> list)：返回指定列表支持的同步（线程安全的）列表
public static <T> List<T> unmodifiableList(List<? extends T> list)返回指定列表的不可修改视图

　　注意：

　　 Collections 类中提供了多个 synchronizedXXX() 方法，该方法可使指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

　　  Collections 类中提供了多个 unmodifiableXXX() 方法，该方法返回指定 XXX 的不可修改的视图。　

　　 说明：

　　　　public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 方法的泛型形参为什么要设定上限为 Object & Comparable？

　　　　这是为了当泛型擦除时，按照 Object 处理，而不是 Comparable 处理，这样就可以和 JDK1.5 之前没有泛型的API 保持一致。

　　Demo：

 ArrayList<String> list = new ArrayList<>();
 Collections.addAll(list,"a","b","c","d","e");   // 往集合中添加一些元素。
 System.out.println(list);//[a, b, c, d, e]
 Collections.shuffle(list);                             // 打乱集合顺序
 System.out.println(list);//[b, d, c, a, e], [b, d, c, a, e]

三、sort 方法

　　public static <T> void sort(List<T> list) 方法

　　　　该方法将集合中元素按照默认规则排序，默认是升序。

　　　　注意：被排序的集合里边存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则。

四、Comparator 比较器

　　上面使用了 sort() 方法进行的是默认排序，如果想要指定顺序那该怎么办呢？

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

　　首先，先来研究下面的这个方法

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

　　Demo:

 1 public class CollectionsDemo2 {
 2     public static void main(String[] args) {
 3         ArrayList<String>  list = new ArrayList<String>();
 4         list.add("cba");
 5         list.add("aba");
 6         list.add("sba");
 7         list.add("nba");
 8         //排序方法
 9         Collections.sort(list);
10         System.out.println(list);
11     }
12 }
13 结果：[aba, cba, nba, sba]

　　通过上面的Demo可以看出使用的默认规则完成字符串的排序，那么默认规则是如何定义出来的呢？

　　说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用 java.lang.Comparable 接口去实现，一种是灵活的当需要做排序的时候在去选择的java.util.Comparator 接口完成。　　

　　上面我们存放的是一个 String 类，打开String类型如下：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {

　　我们发现 String 类实现了这个接口，并完成了比较规则的定义，但是这样就把规则写死了，如果想按照第一个字符降序排列，这就需要修改 String 的源代码，但是这是不可能的，这时我们就可以使用 comparator 接口来实现。

public static <T> void sort(List<T> list，Comparator<? super T> )

　　Comparator 这个接口，位于 java.util 包下面，排序是 comparator 能实现的功能之一，该接口代表一个比较器，比较器具有可比性。

　　下面看一下这个比较的方法：

  public int compare(String o1, String o2)`：比较其两个参数的顺序。

  两个对象比较的结果有三种：大于，等于，小于。

  如果要按照升序排序，
  则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）
  如果要按照降序排序
  则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）

　　Demo：按第一个单词降序

 public class CollectionsDemo3 {
     public static void main(String[] args) {
         ArrayList<String> list = new ArrayList<String>();
         list.add("cba");
         list.add("aba");
         list.add("sba");
         list.add("nba");
         //排序方法  按照第一个单词的降序
         Collections.sort(list, new Comparator<String>() {
             @Override
             public int compare(String o1, String o2) {
                 return o2.charAt(0) - o1.charAt(0);
             }
         });
         System.out.println(list);
     }
 }
 结果：[sba, nba, cba, aba]

五、Comparable 和 Comparator 两个接口的区别

　　Comparable：

　　　　强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compaetTo 方法被称为她的自然比较方法。

　　　　只能在类中实现 compareTo() 一次，不能经常修改类的代码实现自己想要的排序，实现此接口的对象列表（和数组）可以通过 Collection.sort （和 Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无序指定比较器。

　　comparator:

　　　　强行对某个对象进行整体排序。可以将 Comparator 传递给 sort 方法（如Collection.sort 或 Array.sort），从而允许在排序上实现精确控制。

　　　　还可以使用 Comparator 来控制某些数据结构（如有序 set 或有序的映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

　　Demo：

 // 自定义 Student 类
 public class Student{
     private String name;
     private int age;

     public Student() {
     }

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

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

　　测试类：

 public class Demo {

     public static void main(String[] args) {
         // 创建四个学生对象 存储到集合中
         ArrayList<Student> list = new ArrayList<Student>();

         list.add(new Student("rose",18));
         list.add(new Student("jack",16));
         list.add(new Student("abc",16));
         list.add(new Student("ace",17));
         list.add(new Student("mark",16));

         /*
           让学生 按照年龄排序 升序
          */
 //        Collections.sort(list);//要求 该list中元素类型  必须实现比较器Comparable接口

         for (Student student : list) {
             System.out.println(student);
         }

     }
 }

　　这个时候发现调用 Collections.sort()方法的时候 程序报错了。

　　原因：如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。

public class Student implements Comparable<Student>{
    ....
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;//升序
    }
}

　　再补充上面的代码后，就 OK了。

　　当然了，如果在使用的时候，想要独立的定义规则去使用 可以采用Collections.sort(List list,Comparetor<T> c)方式，自己定义规则如下：

Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getAge()-o1.getAge();//以学生的年龄降序
    }
});

　　扩展：如果年龄相同，按姓名第一个字母排序

Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 年龄降序
                int result = o2.getAge()-o1.getAge();//年龄降序

                if(result==0){//第一个规则判断完了 下一个规则 姓名的首字母 升序
                    result = o1.getName().charAt(0)-o2.getName().charAt(0);
                }

                return result;
            }
        });

总结：

　　对于自定义的类型来说，如果想要调用 Collections.sort() 或 Arrays.sort() 方法时，必须指定一个比较器。

　　1、在当前类中 实现 Comparable 接口，重写其中的 compareTo() 方法，在方法里面指定比较方式。

　　2、在调用 sort() 方法的时候，在第二个参数的位置，new Comparor 对象，然后重写 compare 方法。