Collections工具类介绍和应用

Collections工具类
基本介绍：

Collections 是一个操作Set List 和 Map等集合的工具类
Collections 中提供一系静态方法对集合元素进行排序、 查询和修改等操作

排序操作:注意点：排序只能堆List集合排序，不能对数组以及其他类型集合进行排序

常见API如下

方法	说明
reverse(List)	反转List中元素的顺序
shuffle(List)	对List集合元素进行随机排序
sort(List)	根据元素的自然顺序对指定List集合元素按升序排序
sort(List,Comparator)	根据指定的Comparator产生的顺序对List集合元素进行排序

替换 和 查找操作

常见API如下

方法	说明
swap(List, int ,int )	将指定List集合中的 i 处元素 和 j 处元素进行交换
Object max(Collection)	根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection, Comparator)	根据Comparator指定的顺序，返回给集合中的最大元素
Object min(Collection)	根据元素的自然顺序，返回给定集合中的最小元素
Object min(Collection, Comparator)	根据Comparator指定的顺序，返回给集合中的最大元素
int frequency(Collection,Object)	返回指定集合中指定元素的出现次数
void copy(List dest,List src)	将src内容复制到dest,复制的目标长度须大于源集合，否则抛出空指针异常
boolean replaceAll(List list,Object oldVal,Object newVal)	使用新值替换List对象的所有旧值

Collections常用方法代码如下所示：

package com.xzq.collection;

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

/**
 * @Author xiaozq
 * @Date 2023/2/1 13:35
 * <p>@Description:</p>
 */
public class demo {
    public static void main(String[] args) {

        ArrayList list = new ArrayList();
        list.add("白天");
        list.add("蓝云");
        list.add("山川");
        list.add("美景");
        list.add("佳人");
        list.add("蓝云");

        // reverse(List) 反转中元素的顺序 就是将原来的顺序反转,底层调用swap位置交换
        Collections.reverse(list);
        System.out.println(list);

        // shuffle(list) 对List集合元素进行随机排序
        Collections.shuffle(list);
        System.out.println(list);

        // sort 根据元素的自然顺序对指定List集合元素按升序排序
        System.out.print("自然排序：");
        Collections.sort(list);
        System.out.println(list);

        // sort(list , Comparator) 根据指定的Comparator 产生的顺序对List集合元素进行排序
        System.out.print("Comparator制定排序");
        Collections.sort(list, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                String str1 = (String) o1;
                String str2 = (String) o2;
                return str1.compareTo(str2);
            }
        });
        System.out.println(list);

        // swap(List,int ,int) 将指定List集合中 i 处元素  和  j 处元素进行交换
        Collections.swap(list,0,2);
        System.out.println("交换后："+list);

        //Object max(Collection) 根据元素的自然顺序，返回给定集合中最大元素
        Comparable max = Collections.max(list);
        System.out.println("自然排序 max="+max);
        // Object max(Collection,Comparator) 根据Comparator指定的顺序返回给定集合中的最大元素
        Object max1 = Collections.max(list, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String) o1).compareTo((String) o2);
            }
        });
        System.out.println("指定排序规则的最大值="+max1);

        // Object min(Collection) 根据元素的自然排序，返回给定集合的最小值
        // Object min(Collection , Comparator) 根据Comparator指定的顺序返回给定集合中的最小值

        // int frequency(Collection ,Object) 返回指定集合中指定元素的出现次数
        // Collection：集合  Object 该元素出现次数
        int tom = Collections.frequency(list, "山川");
        System.out.println("'山川'出现的次数="+tom);

        // copy(List dest ,List src)：将src中的内容复制到dest中【】
        ArrayList dest = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            dest.add(i);
        }
        Collections.copy(dest,list);
        //注意复制的目标集合的长度必须大于源集合，否则会抛出空指针异常
        System.out.println("复制后集合:"+dest);

        // boolean replaceAll(List list,Object oldVal ,Object newVal)：
        //使用新值替换List对象的所有旧值
        Collections.replaceAll(list,"佳人","落日");//将佳人 替换成 落日
        System.out.println(list);

    }
}

结果如下图所示：

copy( )源码解析

 public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    int srcSize = src.size(); 
       // 如果目标集合的长度不大于源集合长度则会抛出空指针异常
     if (srcSize > dest.size())
         throw new IndexOutOfBoundsException("Source does not fit in dest");
         
       //如果源集合的长度小于10或源集合和目标集合类型是RandomAccess，则执行if块代码
         if (srcSize < COPY_THRESHOLD ||(src instanceof RandomAccess 
              && dest instanceof RandomAccess)) {
                       for (int i=0; i<srcSize; i++)
                          dest.set(i, src.get(i));
                 } else {
                      ListIterator<? super T> di=dest.listIterator();
                      ListIterator<? extends T> si=src.listIterator();
                      for (int i=0; i<srcSize; i++) {
                          di.next();
                           di.set(si.next());
                      }
                  }
              }