Wend看源码-Java-Collections 工具集学习

摘要   

  java.util.Collections它提供了一系列静态方法，用于对集合（如List、Set、Map等）进行操作。这些操作包括排序、查找、替换、同步等多种功能，帮助开发者更方便地处理集合数据。以下是Collections 提供的一些主要方法的总结。

sort

        对指定的 List 进行自然排序（元素需实现 Comparable 接口）。或根据指定的 Comparator 实现来对 List 进行排序，通过自定义 Comparator 可以灵活地定义排序规则，比如实现降序排序或者按照特定业务逻辑排序等。

示例代码

 // 示例1 ：使用 sort 对列表进行排序
    private static void sortList(){

        // 创建一个整数列表
        List<Integer> numberList = new ArrayList<>();
        numberList.add(5);
        numberList.add(3);
        numberList.add(8);
        numberList.add(1);

        // 1. 使用sort方法进行自然排序（升序）
        List<Integer> sortedList = new ArrayList<>(numberList);
        Collections.sort(sortedList);
        System.out.println("升序排序后的列表: " + sortedList);

        // 2. 使用自定义Comparator进行降序排序
        Comparator<Integer> reverseComparator = (a, b) -> b - a;
        Collections.sort(numberList, reverseComparator);
        System.out.println("降序排序后的列表: " + numberList);


    }

binarySearch

        二分查找。在已排序（升序）的 List 中使用二分查找算法查找指定元素 key，返回元素在列表中的索引，如果不存在则返回一个特定的负数表示插入点。

示例代码

// 示例2 ：查找元素（二分查找，要求列表已排序）
    private static void binarySearch() {
        // 创建一个整数列表
        List<Integer> sortedList = new ArrayList<>();
        sortedList.add(1);
        sortedList.add(2);
        sortedList.add(3);
        sortedList.add(4);
        sortedList.add(5);

        // 3. 查找元素（二分查找，要求列表已排序）
        int index = Collections.binarySearch(sortedList, 3);
        System.out.println("元素3在升序排序后的列表中的索引: " + index);
    }

reverse

        反转指定 List 中元素的顺序。

示例代码

 // 示例3 ：反转列表元素顺序
    private static void reverseList() {
        // 创建一个整数列表
        List<Integer> sortedList = new ArrayList<>();
        sortedList.add(1);
        sortedList.add(2);
        sortedList.add(3);
        sortedList.add(4);
        sortedList.add(5);

        // 4. 反转列表元素顺序
        Collections.reverse(sortedList);
        System.out.println("反转后的列表: " + sortedList);
    }

fill

        用指定的对象 obj 填充整个 List，也就是将列表中的所有元素都设置为 obj。

示例代码

 // 示例4 ：填充列表
    private static void fillList() {
        // 创建一个字符串列表
        List<String> stringList = new ArrayList<>();
        stringList.add("old");
        Collections.fill(stringList, "new");
        System.out.println("填充后的字符串列表: " + stringList);
    }

max（最大值）

        根据元素的自然顺序返回集合中的最大元素（元素需实现 Comparable 接口）。或依据指定的 Comparator 返回集合中的最大元素。

min（最小值）

        根据元素的自然顺序返回集合中的最小元素（元素需实现 Comparable 接口）。或依据指定的 Comparator 返回集合中的最小元素。

示例代码

 // 示例5 ：获取最大值和最小值（自然顺序）
    private static void getMaxAndMin() {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(20);
        numberList.add(5);
        System.out.println("最大值（自然顺序）: " + Collections.max(numberList));
        System.out.println("最小值（自然顺序）: " + Collections.min(numberList));
    }

unmodifiableList（不可变集合）

        返回指定 List 的不可变视图，对该视图进行修改操作会抛出 UnsupportedOperationException，可用于保护原始列表不被意外修改。类似的还有 unmodifiableSet、unmodifiableMap 等针对 Set 和 Map 类型创建不可变视图的方法。

示例代码

 // 示例6 ：创建不可变列表视图示例
    private static void createImmutableList() {
        List<Integer> sortedList = new ArrayList<>();
        sortedList.add(1);
        sortedList.add(2);
        sortedList.add(3);
        sortedList.add(4);
        sortedList.add(5);

        // 创建不可变列表视图示例
        List<Integer> immutableList = Collections.unmodifiableList(sortedList);
        // 下面这行代码会抛出UnsupportedOperationException异常，因为不可变视图不允许修改
        // immutableList.add(99);
        // 不可变的Set、Map
        Set<Integer> immutableSet = Collections.unmodifiableSet(new HashSet<>(sortedList));
        Map<Integer, String> immutableMap = Collections.unmodifiableMap(new HashMap<>());
    }

synchronizedList（同步集合）

        返回指定 List 的线程安全的同步包装版本，适用于多线程环境下对列表的操作，避免并发修改异常等问题。同样也有针对 Set 和 Map 的同步包装方法如 synchronizedSet、synchronizedMap。

示例代码

 // 示例7 ：使用 synchronizedList 创建线程安全的列表
    private static void synchronizedList() {
        List<Integer> sortedList = new ArrayList<>();
        sortedList.add(1);
        sortedList.add(2);
        sortedList.add(3);
        sortedList.add(4);
        sortedList.add(5);

        // 创建线程安全的列表
        List<Integer> synchronizedList = Collections.synchronizedList(sortedList);
        // 通过synchronizedList获取的列表是线程安全的，但是需要注意的是，对列表的迭代操作仍然需要手动同步
        synchronized (synchronizedList) {
            for (Integer num : synchronizedList) {
                System.out.println(num);
            }
        }
    }

copy（拷贝）

        将 src 列表中的元素拷贝到 dest 列表中，要求 dest 列表要有足够的空间（通常先创建一个合适大小的目标列表）

nCopies（创建不可变列表并填充指定元素）

        它用于创建一个不可变的List，其中包含指定数量（n）的指定对象（o）。

示例代码

 // 示例8 ：使用 nCopies 创建指定大小的列表，并填充指定元素,使用copy复制一个List
    private static void Copy() {
        List<Integer> sortedList = new ArrayList<>();
        sortedList.add(1);
        sortedList.add(2);
        sortedList.add(3);
        sortedList.add(4);
        sortedList.add(5);

        // 创建一个包含10个元素的列表，每个元素都是0
        List<Integer> copyList = new ArrayList<>(Collections.nCopies(10, 0));
        System.out.println("创建的列表: " + copyList);

        Collections.copy(copyList, sortedList);
        System.out.println("拷贝后: copyList: " + copyList);

    }

shuffle(重新洗牌）

        用于对指定的List进行随机重排（洗牌操作），使得列表中的元素顺序被打乱，并且所有可能的排列出现的概率大致相等。

示例代码

 // 示例9 ：使用 shuffle 对列表进行洗牌
    private static void shuffleList() {
        List<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        Collections.shuffle(arrayList);
        System.out.println("Shuffled ArrayList: " + arrayList);

        List<Integer> linkedList = new LinkedList<>();
        linkedList.add(5);
        linkedList.add(6);
        linkedList.add(7);
        linkedList.add(8);
        Collections.shuffle(linkedList);
        System.out.println("Shuffled LinkedList: " + linkedList);
    }

swap（交换元素)

        用于交换指定列表中两个指定位置上的元素。

// 示例10 ：使用 swap 交换列表中的元素
    private static void swapList() {
        // 创建一个包含若干元素的列表
        List<String> fruitList = new ArrayList<>();
        fruitList.add("Apple");
        fruitList.add("Banana");
        fruitList.add("Cherry");
        fruitList.add("Date");

        System.out.println("交换前的列表: " + fruitList);

        // 使用Collections.swap方法交换列表中指定位置的元素
        // 交换索引为1和索引为3的元素（也就是交换 "Banana" 和 "Date"）
        Collections.swap(fruitList, 1, 3);

        System.out.println("交换后的列表: " + fruitList);
    }

rotate（元素右移）

        用于将指定列表中的元素向右旋转指定的距离。旋转操作会改变列表中元素的顺序，但是不会改变列表的大小。如果旋转的距离大于列表的大小，那么这个距离会被列表的大小取模。旋转的距离是指列表中的元素将要移动的位置数。如果距离是正数，元素将向右移动；如果距离是负数，元素将向左移动。

示例代码

// 示例11 ：使用 rotate 向右旋转列表中的元素
    private static void rotateList() {
        // 创建一个包含若干元素的列表
        List<String> fruitList = new ArrayList<>();
        fruitList.add("Apple");
        fruitList.add("Banana");
        fruitList.add("Cherry");
        fruitList.add("Date");

        // 打印原始列表
        System.out.println("Original list: " + fruitList);

        // 向右旋转列表中的元素，距离为2
        Collections.rotate(fruitList, 2);

        // 打印旋转后的列表
        System.out.println("Rotated list: " + fruitList);
    }

replaceAll（替换全部）

        用于将列表中所有出现的一个指定的元素替换为另一个元素。这个方法会修改原始的列表。调用此方法时，列表中的所有匹配元素都会被替换。

示例代码

 // 示例12 ：replaceAll 替换列表中的元素
    private static void replaceAll(){
        // 创建一个包含若干元素的列表
        List<String> fruitList2 = new ArrayList<>();
        fruitList2.add("Apple");
        fruitList2.add("Banana");
        fruitList2.add("Cherry");
        fruitList2.add("Date");

        // 打印原始列表
        System.out.println("Original list: " + fruitList2);

        // 使用Collections.replaceAll方法替换列表中的元素 将列表中的 "Banana" 替换为 "Grape"
        Collections.replaceAll(fruitList2, "Banana", "Grape");

        // 打印替换后的列表
        System.out.println("Replaced list: " + fruitList2);
    }

indexOfSubList（找到第一个包含子元素的位置）

        用于返回列表中第一次出现的指定子列表的起始索引，如果列表不包含子列表，则返回 -1。

lastIndexOfSubList（找到最后一个包含子元素的位置）

        用于返回列表中最后一次出现的指定子列表的起始索引，如果列表不包含子列表，则返回 -1。

示例代码

 // 示例13 ：indexOfSubList 和 lastIndexOfSubList 查找子列表的位置
    private static void indexOfSubList(){
        // 创建一个包含若干元素的列表
        List<String> fruitList3 = new ArrayList<>();
        fruitList3.add("Apple");
        fruitList3.add("Banana");
        fruitList3.add("Cherry");
        fruitList3.add("Date");
        fruitList3.add("Apple");
        fruitList3.add("Banana");

        // 创建一个包含若干元素的子列表
        List<String> subList = new ArrayList<>();
        subList.add("Apple");
        subList.add("Banana");

        // 使用Collections.indexOfSubList方法查找子列表的位置
        int index1 = Collections.indexOfSubList(fruitList3, subList);
        System.out.println("Index of sublist: " + index1);

        // 使用Collections.lastIndexOfSubList方法查找子列表的位置
        int index2 = Collections.lastIndexOfSubList(fruitList3, subList);
        System.out.println("Last index of sublist: " + index2);
    }

checkedCollection（进行类型检查的集合)

        用于创建一个动态类型安全的集合视图。在运行时会对添加、修改等操作涉及的元素类型进行严格检查，确保集合中的元素类型符合指定的类型要求，若不符合则抛出 ClassCastException 异常，以此增强程序的类型安全性。同样也有针对List、 Set 和 Map 的方法如 checkedList、checkedSet和 checkedMap。

示例代码

 // 示例14 : 使用checkedCollection创建类型检查集合
    private static void checkedCollection(){
        ArrayList rawList = new ArrayList<>();
        rawList.add(1);
        rawList.add("hello");

        // 创建一个只允许存放Integer类型元素的检查集合，以rawList为基础
        Collection checkedCollection = Collections.checkedCollection(rawList, Integer.class);

        try {
            // 尝试添加一个符合要求的Integer元素，操作正常
            checkedCollection.add(2);
            // 尝试添加一个不符合要求的String元素，会抛出ClassCastException
            checkedCollection.add("world");
        } catch (ClassCastException e) {
            System.out.println("类型不匹配，出现异常: " + e.getMessage());
        }
    }

emptyList（创建一个空集合）

        该方法常用于需要返回一个空列表的情况，避免创建不必要的可变列表实例，提升性能和代码的简洁性。同样也有针对Set 和 Map 的方法如emptySet和emptyMap 等。

singletonList(单元素集合）

        方法会创建一个不可变的列表，该列表只包含一个指定的元素。这个列表的长度固定为 1，同样也是不可变的，任何修改操作都会引发 UnsupportedOperationException 异常。常用于只需要表示单个元素的列表场景，比如某些方法要求传入一个列表参数，但实际只有一个值的情况。同样也有针对Set和Map的方法如singleton和singletonMap。

示例代码

// 示例15. 创建空集合,单元素集合
    private static void emptyAndSingleton(){
        // 示例18. 创建空集合
        List<String> empty = Collections.emptyList();
        System.out.println("创建的空列表: " + empty);
        // 示例19. 创建单元素集合
        List<String> singleton = Collections.singletonList("hello");
        System.out.println("创建的单元素列表: " + singleton);
        // 创建单元素只读Map
        Map<String, Integer> readOnlyMap = Collections.singletonMap("key", 1);
        System.out.println("创建的只读Map: " + readOnlyMap);
        // 创建不可变Set
        Set<String> immutableSet2 = Collections.singleton("hello");
        System.out.println("创建的不可变Set: " + immutableSet2);
    }

frequency（统计元素出现次数)

        方法用于统计指定元素在给定集合中出现的次数。它遍历整个集合，通过比较元素是否相等（使用 equals 方法判断）来确定指定元素出现的频次，然后返回对应的整数值。

示例代码

  // 示例15.frequency 计算元素出现的次数
    private static void frequency(){
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("apple");

        int count = Collections.frequency(list, "apple");
        System.out.println("元素 'apple' 在列表中出现的次数: " + count);
    }

disjoint（判断两个列表是否不相交）

        用于判断两个集合是否没有共同的元素（即是否 “不相交”）。它会遍历两个集合中的元素，通过比较元素是否相等（使用 equals 方法判断）来确定它们之间是否存在交集。如果两个集合没有任何相同的元素，则返回 true；反之，若存在至少一个相同元素，则返回 false。

示例代码

 // 示例16.disjoint 判断两个集合是否有交集
    private static void disjoint(){
        List<String> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("b");

        List<String> list2 = new ArrayList<>();
        list2.add("c");
        list2.add("d");

        boolean disjoint = Collections.disjoint(list1, list2);
        System.out.println("两个集合是否不相交: " + disjoint);

        List<String> list3 = new ArrayList<>();
        list3.add("a");
        list3.add("e");

        disjoint = Collections.disjoint(list1, list3);
        System.out.println("另外两个集合是否不相交: " + disjoint);
    }

newSetFromMap

        方法利用给定的 Map 来创建一个 Set。实际上返回的 Set 实现是基于传入的 Map 的，Set 中的元素对应 Map 的键，添加到 Set 中的元素会在 Map 中相应地添加键，并将对应的值设置为 Boolean.TRUE。这个方法常用于需要自定义 Set 的一些特性（例如基于特定的 Map 实现来获得不同的性能、同步等特性）的场景。

示例代码

// 示例17. 使用newSetFromMap创建基于Map的Set
    private static void newSetFromMap(){
        Map<String, Boolean> underlyingMap = new HashMap<>();
        // 基于自定义的Map创建一个Set
        Set<String> customSet = Collections.newSetFromMap(underlyingMap);

        customSet.add("element1");
        customSet.add("element2");

        System.out.println("基于Map创建的Set: " + customSet);
        System.out.println("对应的Map内容: " + underlyingMap);
    }

相关推荐

        开源项目 JavaUsefulMode:JavaUsefulMode: 基于Java 语言的自定义实用工具集

        JavaUsefulMode是小编编写Java方向学习专栏时的代码示例汇总总结，其中包含了本章节对于java.util.Collections的工具类学习的代码示例，感兴趣的小伙伴可以直接下载学习。