Java Collections工具类：高效集合操作

Collections工具类概述

Collections是Java提供的集合操作工具类，位于java.util包中，包含大量静态方法，用于对List、Set、Map等集合进行排序、查找、替换、同步化等操作。

---

常用方法及代码示例

排序操作

sort(List<T> list)：对List进行自然排序（元素需实现Comparable接口）。
sort(List<T> list, Comparator<? super T> c)：根据自定义比较器排序。

List<Integer> numbers = Arrays.asList(3, 1, 4, 2);
Collections.sort(numbers); // 自然排序
System.out.println(numbers); // [1, 2, 3, 4]

// 自定义排序（降序）
Collections.sort(numbers, (a, b) -> b - a);
System.out.println(numbers); // [4, 3, 2, 1]

查找操作

binarySearch(List<? extends Comparable<? super T>> list, T key)：二分查找（需先排序）。

List<String> words = Arrays.asList("apple", "banana", "cherry");
Collections.sort(words); // 必须先排序
int index = Collections.binarySearch(words, "banana");
System.out.println(index); // 1

反转与乱序

reverse(List<?> list)：反转集合元素顺序。
shuffle(List<?> list)：随机打乱顺序。

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
Collections.reverse(list);
System.out.println(list); // [3, 2, 1]

Collections.shuffle(list);
System.out.println(list); // 随机顺序如 [2, 1, 3]

同步化集合

synchronizedList(List<T> list)：将非线程安全的List转为线程安全版本。

List<String> unsafeList = new ArrayList<>();
List<String> safeList = Collections.synchronizedList(unsafeList);
// 多线程操作安全

不可变集合

unmodifiableList(List<? extends T> list)：返回不可修改的视图。

List<String> mutable = new ArrayList<>(Arrays.asList("A", "B"));
List<String> immutable = Collections.unmodifiableList(mutable);
immutable.add("C"); // 抛出UnsupportedOperationException

填充与频率

fill(List<? super T> list, T obj)：用指定元素填充集合。
frequency(Collection<?> c, Object o)：统计元素出现次数。

List<String> items = new ArrayList<>(Arrays.asList("A", "B", "A"));
Collections.fill(items, "X");
System.out.println(items); // [X, X, X]

int freq = Collections.frequency(items, "X");
System.out.println(freq); // 3

---

其他实用方法

• max(Collection<? extends T> coll)：返回最大值。
• min(Collection<? extends T> coll)：返回最小值。
• swap(List<?> list, int i, int j)：交换元素位置。

List<Integer> nums = Arrays.asList(5, 8, 2);
System.out.println(Collections.max(nums)); // 8
Collections.swap(nums, 0, 2);
System.out.println(nums); // [2, 8, 5]

实例：

package com.itheima.a07mycollections;

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

public class CollectionsDemo2 {
    public static void main(String[] args) {
      /*
        public static <T> boolean addAll(Collection<T> c, T... elements) 批量添加元素
        public static void shuffle(List<?> list)                        打乱List集合元素的顺序
        public static <T> void sort(List<T> list)                       排序
        public static <T> void sort(List<T> list, Comparator<T> c)      根据指定的规则进行排序
        public static <T> int binarySearch (List<T> list,  T key)       以二分查找法查找元素
        public static <T> void copy(List<T> dest, List<T> src)          拷贝集合中的元素
        public static <T> int fill (List<T> list,  T obj)               使用指定的元素填充集合
        public static <T> void max/min(Collection<T> coll)              根据默认的自然排序获取最大/小值
        public static <T> void swap(List<?> list, int i, int j)         交换集合中指定位置的元素
     */

        System.out.println("-------------addAll默认规则--------------------------");
         //1.创建集合
        ArrayList<String> list = new ArrayList<>();

        //2.调用方法
        //批量添加元素
        Collections.addAll(list,"5","8","1","4","7","9");
        System.out.println(list);
  
        System.out.println("-------------shuffle默认规则--------------------------");
        //打乱集合元素顺序
        Collections.shuffle(list);
        System.out.println(list);

        System.out.println("-------------sort默认规则--------------------------");
        //默认规则，需要重写Comparable接口compareTo方法。Integer已经实现，按照从小打大的顺序排列
        //如果是自定义对象，需要自己指定规则
        ArrayList<Integer> list1 = new ArrayList<>();
        Collections.addAll(list1, 10, 1, 2, 4, 8, 5, 9, 6, 7, 3);
        Collections.sort(list1);
        System.out.println(list1);


        System.out.println("-------------sort自己指定规则规则--------------------------");
        Collections.sort(list1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(list1);

        Collections.sort(list1, (o1, o2) -> o2 - o1);
        System.out.println(list1);

        System.out.println("-------------binarySearch--------------------------");
        //需要元素有序
        ArrayList<Integer> list2 = new ArrayList<>();
        Collections.addAll(list2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(Collections.binarySearch(list2, 9));
        System.out.println(Collections.binarySearch(list2, 1));
        System.out.println(Collections.binarySearch(list2, 20));

        System.out.println("-------------copy--------------------------");
        //把list3中的元素拷贝到list4中
        //会覆盖原来的元素
        //注意点：如果list3的长度 > list4的长度，方法会报错
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<Integer> list4 = new ArrayList<>();
        Collections.addAll(list3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Collections.addAll(list4, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
        Collections.copy(list4, list3);
        System.out.println(list3);
        System.out.println(list4);

        System.out.println("-------------fill--------------------------");
        //把集合中现有的所有数据，都修改为指定数据
        ArrayList<Integer> list5 = new ArrayList<>();
        Collections.addAll(list5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Collections.fill(list5, 100);
        System.out.println(list5);

        System.out.println("-------------max/min--------------------------");
        //求最大值或者最小值
        ArrayList<Integer> list6 = new ArrayList<>();
        Collections.addAll(list6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(Collections.max(list6));
        System.out.println(Collections.min(list6));

        System.out.println("-------------max/min指定规则--------------------------");
        // String中默认是按照字母的abcdefg顺序进行排列的
        // 现在我要求最长的字符串
        // 默认的规则无法满足，可以自己指定规则
        // 求指定规则的最大值或者最小值
        ArrayList<String> list7 = new ArrayList<>();
        Collections.addAll(list7, "a","aa","aaa","aaaa");
        System.out.println(Collections.max(list7, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        }));

        System.out.println("-------------swap--------------------------");
        ArrayList<Integer> list8 = new ArrayList<>();
        Collections.addAll(list8, 1, 2, 3);
        Collections.swap(list8,0,2);
        System.out.println(list8);



    }
}

练习一：

package test._Collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class test02 {
    public static void main(String[] args) {
        /*
        班级里有N个学生，学生属性:姓名，年龄，性别。
        实现随机点名器。
        */
        //1.定义集合
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list,"范闲","范建","范统","杜子腾","杜琦燕","宋合泛","侯笼藤","朱益群","朱穆朗玛峰","袁明媛");
        //方法一：
        //Random r =new Random();
//        int index = r.nextInt(list.size());
//        String s  = list.get(index);
//        System.out.println(s);

        //方法二：
        Collections.shuffle(list);
        System.out.println(list.get(0));

    }
}

练习二：

package test._Collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class test03 {
    /* 班级里有N个学生
    要求：
    70%的概率随机到男生
    30%的概率随机到女生

    "范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰",
    "杜琦燕","袁明媛","李猜","田蜜蜜",
    */
    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,1,1,1,1,1,1);
        Collections.addAll(list,0,0,0);

        Random r = new Random();
        int index = r.nextInt(list.size());
        int number = list.get(index);
        System.out.println(number);

        ArrayList<String> boylist = new ArrayList<>();
        ArrayList<String> girllist = new ArrayList<>();
        Collections.addAll(boylist, "范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰");
        Collections.addAll(girllist,"杜琦燕","袁明媛","李猜","田蜜蜜");
        if(number == 1){
            int boyindex = r.nextInt(boylist.size());
            String name = boylist.get(boyindex);
            System.out.println(name);
        }else if(number == 0){
            int girlindex = r.nextInt(girllist.size());
            String name = girllist.get(girlindex);
            System.out.println(name);
        }
    }
}

练习三：

package test._Collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class test04 {
    /* 班级里有10个学生
    要求：
    被点到的学生不会再被点到。
    但是如果班级中所有的学生都点完了，需要重新开启第二轮点名。
    */
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"范闲","范建","范统","杜子腾","杜琦燕","宋合泛","侯笼藤","朱益群","朱穆朗玛峰","袁明媛");
        ArrayList<String> list2 = new ArrayList<>();
        int count = list.size();
        Random r = new Random();

        for (int i = 0; i < 10; i++) {
            System.out.println("-------第"+i+"轮抽点");
            for (int j = 0; j < count; j++) {
                int index = r.nextInt(list.size());
                String name = list.remove(index);
                list2.add(name);
                System.out.println(name);
            }
            list.addAll(list2);
            list2.clear();
        }


    }
}

练习四：

package test._Collections;

import java.awt.event.KeyListener;
import java.util.*;

public class test05 {
    public static void main(String[] args) {
        /* 需求
        定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。
        添加完毕后，遍历结果格式如下：
        江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
        湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
        河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市*/

        //1.创建集合
        HashMap<String,ArrayList<String>> hm = new HashMap<>();

        //2.创建单列结合存储市
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("南京市");
        list1.add("扬州市");
        list1.add("苏州市");
        list1.add("无锡市");
        list1.add("常州市");

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("武汉市");
        list2.add("孝感市");
        list2.add("十堰市");
        list2.add("宜昌市");
        list2.add("鄂州市");

        ArrayList<String> list3 = new ArrayList<>();
        list3.add("石家庄市");
        list3.add("唐山市");
        list3.add("邢台市");
        list3.add("保定市");
        list3.add("张家口市");

        //3.在双列集合中添加元素
        hm.put("江苏省",list1);
        hm.put("湖北省",list2);
        hm.put("河北省",list3);

        //4，通过遍历对键值对对象进行输出
        Set<Map.Entry<String,ArrayList<String>>> entries = hm.entrySet();
        for (Map.Entry<String, ArrayList<String>> entry : entries) {
            String key = entry.getKey();
            ArrayList<String> value = entry.getValue();
            //5.按照需求的格式进行拼接输出
            StringJoiner sj = new StringJoiner(",","","");
            for (String city : value) {
                sj.add(city);
            }
            System.out.println(key+"="+sj);
        }

    }
}

---

通过合理使用Collections工具类，可以简化集合操作并提升代码效率。注意线程安全问题和不可变集合的限制。