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

Collections类

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

Collections类的常用方法

这里介绍四个常用方法：

addAll(Collection<T> c, T ... elements)

shuffle(List<?> list)

sort(List<r> list)

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

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<T> c, T ... elements)方法

参数说明：

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

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

方法功能：

往集合中添加一些元素

例子：

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);
    }
}

输出结果：
[a, b, c, d, e, f, g]

shuffle(List<?> list)方法

参数说明：

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

方法功能：

打乱集合的顺序。

例子：

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);
    }
}

输出结果：
没有打乱时的集合：[A, B, C, D, E, F, G]
打乱以后的集合：[D, B, C, E, A, G, F]

sort(List<r> list)方法

参数说明：

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

方法功能：

对集合进行排序（默认为升序排序）

例子：

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);
    }
}

输出结果：
没有排序时的集合：[1, 2, 10, 9, 8]
排序后的集合：[1, 2, 8, 9, 10]

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

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

参数说明：

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

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

方法功能：

对集合进行排序（默认为升序排序）

例子：

// 随便创建一个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;
    }
}

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

// 举例
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);
    }
}

输出结果：
没有排序时的集合：[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}]

排序规则代码的理解：

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();
            }
        }