Java 集合的工具类Collections的常用方法

Collections类：java.utils.Collections是集合工具类，用来对集合进行操作。

Collections类的常用方法

复制
public static <T> boolean adda1l(Collection<T> c, T ... elements)// 往集合中添加一些元素。
 
public static void shuff1e(List<?> 1ist)// 打乱顺序:打乱集合顺序。
 
public static <T> void sort(List<r> 1ist)// 将集合中元素按照默认规则排序。
 
public static <T> void sort(List<T> list, Comparator<? super T>)// 将集合中元素按照指定规则排序。

addAll(Collection c, T ... elements)方法

  1. 参数说明：

    Collection c：是要被添加元素的集合

    T ... elements：可变参数，是要给集合添加的元素

  2. 方法功能：往集合中添加一些元素

  3. 例子：

    复制
    		import java.util.Collections;
    		import java.util.HashSet;
    		 
    		public class DemoCollections {
    		    public static void main(String[] args) {
    		        // 创建一个HashSet集合
    		        HashSet<String> hashSet = new HashSet<>();
    		 
    		        // 调用Collections类的静态方法addAll，往集合hashSet中添加多个元素
    		        Collections.addAll(hashSet, "a", "b", "c", "d", "e", "f", "g");
    		 
    		        // 输出HashSet集合
    		        System.out.println(hashSet);
    		    }
    		}

  4. 输出结果：

    复制
    		[a, b, c, d, e, f, g]

shuffle(List<?> list)方法

  1. 参数说明：List<?> list：表示传入的集合，即该方法传入的参数是一个集合

  2. 方法功能：打乱集合的顺序。

  3. 例子：

    复制
    		import java.util.ArrayList;
    		import java.util.Collections;
    		 
    		public class DemoCollectionsShuffle {
    		    public static void main(String[] args) {
    		        // 创建一个ArrayList集合
    		        ArrayList<String> arrayList = new ArrayList<>();
    		 
    		        // 往arrayList集合中添加元素
    		        Collections.addAll(arrayList, "A", "B", "C", "D", "E", "F", "G");
    		        System.out.println("没有打乱时的集合：" + arrayList);
    		 
    		        // 调用Collections类的静态方法shuffle，将集合arrayList里面的元素顺序打乱
    		        Collections.shuffle(arrayList);
    		        System.out.println("打乱以后的集合：" + arrayList);
    		    }
    		}

  4. 输出结果：

    复制
    		没有打乱时的集合：[A, B, C, D, E, F, G]
    		打乱以后的集合：[D, B, C, E, A, G, F]

sort(List list)方法

  1. 参数说明：List<?> list：表示传入的集合，即该方法传入的参数是一个集合

  2. 方法功能：对集合进行排序（默认为升序排序）

  3. 例子：

    复制
    		import java.util.ArrayList;
    		import java.util.Collections;
    		 
    		public class Demo01CollectionsSort {
    		    public static void main(String[] args) {
    		        // 创建一个ArrayList集合
    		        ArrayList<Integer> arrayList = new ArrayList<>();
    		 
    		        // 往arrayList集合中添加元素
    		        Collections.addAll(arrayList, 1, 2, 10, 9, 8);
    		        System.out.println("没有排序时的集合：" + arrayList);
    		 
    		        // 调用sort()方法，将集合arrayList里面的元素进行排序
    		        Collections.sort(arrayList);
    		        System.out.println("排序后的集合：" + arrayList);
    		    }
    		}

  4. 输出结果：

    复制
    		没有排序时的集合：[1, 2, 10, 9, 8]
    		排序后的集合：[1, 2, 8, 9, 10]

sort(List list, Comparator<? super T>)方法

首先，说明一下，这个方法仅做了解即可，学习过程中通常都是默认使用sort(List list)方法的。

  1. 参数说明：

    List<?> list：表示传入的集合，即该方法传入的第一个参数是一个集合

    Comparator<? super T>：这是一个排序规则，自定义（覆盖重写该接口的排序方法）

  2. 方法功能：对集合进行排序（默认为升序排序）

  3. 例子：

    复制
    		// 随便创建一个Person类
    		public class Person {
    		    private String name;
    		    private int age;
    		 
    		    public Person() {
    		    }
    		 
    		    public Person(String name, int age) {
    		        this.name = name;
    		        this.age = age;
    		    }
    		 
    		    @Override
    		    public String toString() {
    		        return "Person{" +
    		                "name='" + name + '\'' +
    		                ", age=" + age +
    		                '}';
    		    }
    		 
    		    public String getName() {
    		        return name;
    		    }
    		 
    		    public void setName(String name) {
    		        this.name = name;
    		    }
    		 
    		    public int getAge() {
    		        return age;
    		    }
    		 
    		    public void setAge(int age) {
    		        this.age = age;
    		    }
    		}

  4. 自己定义一个排序规则进行测试：

    复制
    		// 举例
    		import java.util.ArrayList;
    		import java.util.Collections;
    		import java.util.Comparator;
    		 
    		public class Demo02CollectionsSort {
    		 
    		    public static void main(String[] args) {
    		        // 创建一个ArrayList集合
    		        ArrayList<Person> arrayList = new ArrayList<>();
    		 
    		        // 往arrayList集合中添加元素，集合存储的数据的类型是自定义类型(Person)
    		        Collections.addAll(
    		                arrayList,
    		                new Person("LeeHua", 20),
    		                new Person("WanTao", 18),
    		                new Person("XiaMin", 22),
    		                new Person("HonMao", 22)
    		        );
    		        System.out.println("没有排序时的集合：" + arrayList);
    		 
    		        // 自定义排序规则，对arrayList集合进行排序
    		        Collections.sort(arrayList, new Comparator<Person>() {
    		            @Override
    		            public int compare(Person o1, Person o2) {
    		                // 年龄相等，按照名字排序
    		                while (o1.getAge() - o2.getAge() == 0) {
    		                    if (o1.getName().length() > o2.getName().length()) {
    		                        for (int i = 0; i < o2.getName().length(); i++) {
    		                            if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
    		                                return o1.getName().charAt(i) - o2.getName().charAt(i);
    		                            }
    		                        }
    		                        return 1;
    		                    }
    		                    else if (o1.getName().length() < o2.getName().length()) {
    		                        for (int i = 0; i < o1.getName().length(); i++) {
    		                            if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
    		                                return o1.getName().charAt(i) - o2.getName().charAt(i);
    		                            }
    		                        }
    		                        return - 1;
    		                    }
    		                    else {
    		                        for (int i = 0; i < o2.getName().length(); i++) {
    		                            if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
    		                                return o1.getName().charAt(i) - o2.getName().charAt(i);
    		                            }
    		                        }
    		                        return 0;
    		                    }
    		                }
    		                // 年龄不相等，按照年龄排序
    		                return o1.getAge() - o2.getAge();
    		            }
    		        });
    		        System.out.println("排序以后的集合：" + arrayList);
    		    }
    		}

  5. 输出结果：

    复制
    		没有排序时的集合：[Person{name='LeeHua', age=20}, Person{name='WanTao', age=18}, Person{name='XiaMin', age=22}, Person{name='HonMao', age=22}]
    		排序以后的集合：[Person{name='WanTao', age=18}, Person{name='LeeHua', age=20}, Person{name='HonMao', age=22}, Person{name='XiaMin', age=22}]

  6. 排序规则代码及注释

    复制
    		new Comparator<Person>() {
    		            @Override
    		            public int compare(Person o1, Person o2) {
    		                // 首先判断年龄是否相等
    		                while (o1.getAge() - o2.getAge() == 0) {
    		                    // 如果this年龄 == object年龄，那么就按名字的字母(char code)比较
    		                    // 按照名字的每个字母来比较
    		                    if (o1.getName().length() > o2.getName().length()) {
    		                        // o1的名字长度 > o2的名字长度
    		                        for (int i = 0; i < o2.getName().length(); i++) {
    		                            if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
    		                                return o1.getName().charAt(i) - o2.getName().charAt(i);
    		                            }
    		                        }
    		                        // 假如o2的名字的所有字母，按顺序都与o1的名字对应位数的字母相等，字母长度大的排后，即o1排后
    		                        return 1;
    		                    }
    		                    // o1的名字长度 < o2的名字长度
    		                    else if (o1.getName().length() < o2.getName().length()) {
    		                        for (int i = 0; i < o1.getName().length(); i++) {
    		                            if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
    		                                return o1.getName().charAt(i) - o2.getName().charAt(i);
    		                            }
    		                        }
    		                        // 假如o1的名字的所有字母，按顺序都与o2的名字对应位数的字母相等，字母长度大的排后，即o2排后
    		                        return - 1;
    		                    }
    		                    // o1的名字长度 = o2的名字长度
    		                    else {
    		                        for (int i = 0; i < o2.getName().length(); i++) {
    		                            if (o1.getName().charAt(i) - o2.getName().charAt(i) != 0 ) {
    		                                return o1.getName().charAt(i) - o2.getName().charAt(i);
    		                            }
    		                        }
    		                        // 假如o1的名字的所有字母，按顺序都与o2的名字对应位数的字母相等，那么按照arrayList集合的添加顺序排序
    		                        return 0;
    		                    }
    		                }
    		                // 年龄不相等，按照年龄排序
    		                return o1.getAge() - o2.getAge();
    		            }
    		        }
posted @   LeeHua  阅读(1648)  评论(0)  编辑  收藏  举报
编辑推荐：
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· winform 绘制太阳，地球，月球 运作规律
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示
AI IDE Trae

目录导航