前言

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

1. 排序操作

以下均为static方法：

• reverse （List）：反转 List 中元素的排序；
• shuffle （List） ： 对 List 集合元素进行随机排序；
• sort （List） ： 根据元素的自然顺序对指定的 List 集合元素按升序排序；
• sort （List，Comparator） ：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序；
• swap （List ，int，int） ：将指定 List 集合中的 i 处元素 和 j 处元素进行交换；

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

public class CollectionsSortSwapExample {
    public static void main(String[] args) {
        // 创建ArrayList集合，用于测试
        List<String> list = new ArrayList<>();
        list.add("Jack");
        list.add("Tom");
        list.add("Smith");
        list.add("Rose");

        // 反转List集合中的元素顺序
        Collections.reverse(list);
        System.out.println("反转后的顺序：" + list); // [Rose, Smith, Tom, Jack]

        // 对List集合进行随机排序
        Collections.shuffle(list);
        System.out.println("随机排序后：" + list); // 结果每次运行可能不同

        // 根据元素的自然顺序对List集合元素按升序排序
        Collections.sort(list);
        System.out.println("自然顺序排序后：" + list); // [Jack, Rose, Smith, Tom]

        // 根据字符串长度对List集合元素进行排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length(); // 按字符串长度升序排序
            }
        });
        System.out.println("按长度排序后：" + list); // [Tom, Jack, Rose, Smith]

        // 交换List集合中指定位置的元素
        Collections.swap(list, 1, 2); // 交换索引为1和2的元素
        System.out.println("交换后的顺序：" + list); // [Tom, Rose, Jack, Smith]
    }
}

2. 查找、替换操作

• Object max ( Collection ) ：根据元素的自然顺序，返回给定集合中的最大元素；
• Object max ( Collection , Comparator ) ：根据 Comparator 指定的顺序，返回给定集合中的最大元素；
• Object min ( Collection )
• Object min ( Collection , Comparator)
• int frequency ( Collection , Object ) ： 返回指定集合中指定元素的出现次数；
• void copy ( List dest , List src ) ： 将 src 中的内容复制到 dest 中；
• boolean replaceAll ( List list , Object oldVal , Object newVal ) ： 使用新值替换List对象的所有旧值；

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

public class CollectionsFindReplaceExample {
    public static void main(String[] args) {
        // 创建ArrayList集合，用于测试
        List<String> list = new ArrayList<>();
        list.add("Jack");
        list.add("Tom");
        list.add("Smith");
        list.add("Rose");

        // 查找集合中的最大元素（自然顺序）
        String maxElement = Collections.max(list);
        System.out.println("自然顺序最大元素：" + maxElement); // Tom

        // 查找集合中的最大元素（自定义Comparator）
        String maxLengthElement = Collections.max(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length(); // 按字符串长度比较
            }
        });
        System.out.println("长度最大的元素：" + maxLengthElement); // Smith

        // 查找集合中指定元素的出现次数
        int frequency = Collections.frequency(list, "Rose");
        System.out.println("Rose 出现次数：" + frequency); // 1

        // 将src中的内容复制到dest中
        List<String> dest = new ArrayList<>(Collections.nCopies(list.size(), null));
        Collections.copy(dest, list);
        System.out.println("复制后的列表：" + dest); // [Jack, Tom, Smith, Rose]

        // 替换List中的所有旧值
        Collections.replaceAll(list, "Tom", "Thomas");
        System.out.println("替换后的列表：" + list); // [Jack, Thomas, Smith, Rose]
    }
}

3. 开发中如何选择集合实现类

在实际开发中，选择什么集合实现类，主要取决于业务操作的特点，然后根据集合实现类特性进行选择

先判断存储的类型（一组对象或一组键值对）：

• 一组对象 【单列】：Collection 接口
  • 允许重复：List
    • 增删多：LinkedList （底层维护了一个双向链表）
    • 改查多：ArrayList（底层维护 Object类型的可变数组）
  • 不允许重复：Set
    • 无序：HashSet（底层是HashMap，维护了一个哈希表，即数组+链表+红黑树）
    • 排序：TreeSet
    • 插入和取出顺序一致：LinkedHashSet（维护数组+双向链表）
• 一组键值对 【双列】：Map
  • 键无序：HashMap（底层是哈希表，JDK8:数组+链表+红黑树）
  • 键排序：TreeMap
  • 键插入和取出顺序一致：LinkedHashMap
  • 读取文件：Properties