Collections类

Collections类为Java的常用工具类，下面介绍它的一些常用方法：

1. 排序

• static sort(Listlist);
• static sort(Listlist, Comparator<? super T> com);

  根据元素的自然顺序或自定义比较器指定顺序来对列表中的元素进行排序

public void sortDemo() {
    //初始化列表
    List<Integer> integerList = new ArrayList<>();
    integerList.add(42);
    integerList.add(48);
    integerList.add(3);
    integerList.add(2);
    //初始顺序为 42, 48, 3, 2
    
    //sort方法对integerList进行排序，默认从小到大排序
    Collections.sort(integerList);
    System.out.println(integerList);//[2, 3, 42, 48]
    
    //自定义比较器类，从大到小排序
    Collections.sort(integerList, new MyComparator());
    System.out.println(integerList);	//[48, 42, 3, 2]
}

//自定义比较器类，从大到小排序
class MyComparator implements Comparator<Integer> {

    @Override
    public int compare(Integer o1, Integer o2) {
        if (o1 > o2) 
            return -1;
        else if (o1 < o2)
            return 1;
        return 0;
    }	
}

2. 交换

• static swap(List<?> list, int i, int j);

  对指定List的指定角标的两个元素进行位置交换

  public void swapDemo() {
      //初始化列表
      List<Integer> integerList = new ArrayList<>();
      integerList.add(42);
      integerList.add(48);
      integerList.add(3);
      integerList.add(2);
      
      //指定List的指定角标的两个元素进行位置交换
      Collections.swap(integerList, 0, 3);
      System.out.println(integerList);	//[2, 48, 3, 42]
  }

3. 折半查询

• static binarySearch(List<? extends Comparable<? super T>> list, T key);

  二分查找方法，根据指定key来查询List中的对应元素下标

  public void binarySearchDemo() {
      //初始化列表
      List<Integer> integerList = new ArrayList<>();
      integerList.add(40);
      integerList.add(41);
      integerList.add(42);
      integerList.add(43);
      
      //通过指定的key查找List对应的下标
      int index = Collections.binarySearch(integerList, 43);
      System.out.println(index); //3
  }

4. 最值

该方法用于求集合元素的最大值，同时可以自定义比较器来规定大小的判定规则

• max (Collection<? extends T> coll);
• max (Collection<? extends T> coll, Comparator<? super T> comp);

public void getMaxValue() {
    //初始化列表
    List<Integer> integerList = new ArrayList<>();
    integerList.add(40);
    integerList.add(41);
    integerList.add(42);
    integerList.add(43);
    
    Integer max = Collections.max(integerList);
    System.out.println(max);	//43
    
    Integer max2 = Collections.max(integerList, new MyComparator());
    System.out.println(max2);	//40
}

5. 逆序

• reverse (List<?> list)：反转指定列表中的元素的顺序
• reverseOrder()：返回一个比较器，它强行逆转实现了Comparable接口对象Collection的自然顺序。
• reverseOrder(Comparatorcmp)：返回一个比较器，它强行逆转指定比较器的顺序。

  public void reverseDemo() {
      //初始化列表
      List<Integer> integerList = new ArrayList<>();
      integerList.add(40);
      integerList.add(5);
      integerList.add(45);
      integerList.add(33);//[45, 40, 33, 5]
      
      Collections.reverse(integerList);
      System.out.println(integerList);	//[33, 45, 5, 40]
      
      Comparator<Object> comparator = Collections.reverseOrder();
      integerList.sort(comparator);	//使用比较器再次逆转回来
      System.out.println(integerList);  //[45, 40, 33, 5]
      
      Comparator<Integer> comparator2 = Collections.reverseOrder(new MyComparator());
      //MyComparator比较器是实现从大到小进行逆序排序的
      //使用reverseOrder进行反转之后，获取了自然排序的比较器comparator2
      integerList.sort(comparator2);	//根据自然排序的比较其来排序（虽然默认也是自然排序）
      System.out.println(integerList);  //[5, 33, 40, 45]	
  }

6. 替换

• boolean replaceAll(List<?> list, T oldVal, T newVal)：替换失败则返回false，否则返回true
• fill (List<? super T> list, T obj)：使用指定元素替换列表中的所有元素

  public void replaceAllAndFillDemo() {
      //初始化列表
      List<Integer> integerList = new ArrayList<>();
      integerList.add(40);
      integerList.add(5);
      integerList.add(45);
      integerList.add(33);//[45, 40, 33, 5]
      
      Collections.replaceAll(integerList, 5, 6);
      System.out.println(integerList);	//[40, 6, 45, 33]
      
      Collections.replaceAll(integerList, 40, 33);//33是已存在的值
      System.out.println(integerList);	//[33, 6, 45, 33]
      
      boolean flag = Collections.replaceAll(integerList, -1, 100);  //-1不存在
      System.out.println(flag);  //false
      
      //将集合中的元素全部替换为100
      Collections.fill(integerList, 100);
      System.out.println(integerList);	//[100, 100, 100, 100]
  }

7. 其他

• shuffle(List<?> list)：对列表中的元素的位置进行随机变换，可以用于洗牌。
• ListsynchronizedList( Listlist)：将非同步的集合转换成同步的集合。

  public void shuffleDemo() {
      //初始化列表
      List<Integer> integerList = new ArrayList<>();
      integerList.add(40);
      integerList.add(5);
      integerList.add(45);
      integerList.add(33);//[45, 40, 33, 5]
      
      Collections.shuffle(integerList);
      System.out.println(integerList);	//[5, 45, 40, 33]
  }