Java Collections 类中常用方法使用

一、Collections类

java.util.Collections 类是 Java 集合框架中的一个工具类，提供了一系列静态方法来操作和处理各种类型的集合。这些方法简化了对集合进行排序、查找、同步控制、创建只读集合等常见操作的过程。

二、常用方法

方法类别‌	‌方法签名‌	‌功能‌	‌需求/约束‌	‌算法/返回值‌
‌排序‌	sort(List<T> list)	对列表元素按自然顺序升序排序	元素必须实现 Comparable 接口	归并排序或 TimSort
	sort(List<T> list, Comparator<? super T> c)	按自定义比较器排序	需提供 Comparator 对象	同上
‌查找‌	binarySearch(List<? extends Comparable<? super T>> list, T key)	二分查找元素	列表必须已按自然顺序排序	找到返回索引；未找到返回 -(插入点) - 1
	binarySearch(List<? extends T> list, T key, Comparator<? super T> c)	使用自定义比较器二分查找	列表必须按比较器规则排序	同上
‌最大值/最小值‌	max(Collection<? extends T> coll)	返回集合中的最大元素	元素实现 Comparable 接口	-
	min(Collection<? extends T> coll)	返回集合中的最小元素	同上	-
	max(Collection<? extends T> coll, Comparator<? super T> comp)	使用比较器返回最大元素	需提供 Comparator	-
	min(Collection<? extends T> coll, Comparator<? super T> comp)	使用比较器返回最小元素	同上	-
‌反转‌	reverse(List<?> list)	反转列表元素顺序	-	-
‌随机排序‌	shuffle(List<?> list)	随机打乱列表顺序	-	默认使用 Random 类
	shuffle(List<?> list, Random rnd)	使用指定随机源打乱顺序	需提供 Random 对象	-
‌填充‌	fill(List<? super T> list, T obj)	用指定对象填充列表所有元素	目标列表长度不变	-
‌复制‌	copy(List<? super T> dest, List<? extends T> src)	将源列表元素复制到目标列表	目标列表长度 ≥ 源列表长度	直接覆盖目标列表元素
‌交换‌	swap(List<?> list, int i, int j)	交换列表中两个索引位置的元素	i 和 j 必须在列表有效范围内	-

三、综合应用

1、操作学生信息如下：

1. 创建学生列表
2. 添加学生
3. 打印原始学生列表
4. 对学生列表进行排序（按年龄升序）
5. 查找年龄最大的学生
6. 查找年龄最小的学生
7. 反转学生列表
8. 替换年龄最小的学生的信息
9. 填充学生列表
10. 复制学生列表
11. 交换两个学生的位置
12. 旋转学生列表
13. 随机打乱学生列表
14. 使用二分查找查找特定学生（按年龄排序后，但示例中查找的年龄与注释不匹配）

2、编码

Student类

public class Student {
    private String id;
    private String name;
    private int age;

    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    // Getters 和 Setters
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

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


    @Override
    public String toString() {
        return "Student{id='" + id + "', name='" + name + "', age=" + age + "}";
    }

}

StudentManager类

public class StudentManager {
    public static void main(String[] args) {
        // 创建学生列表
        List<Student> students = new ArrayList<>();

        // 添加学生
        students.add(new Student("001", "Alice", 22));
        students.add(new Student("002", "Bob", 25));
        students.add(new Student("003", "Charlie", 23));
        students.add(new Student("004", "Diana", 21));

        // 打印原始学生列表
        System.out.println("原始数据:");
        for (Student student : students) {
            System.out.println(student);
        }

        // 对学生列表进行排序（按年龄升序）
        Collections.sort(students, Comparator.comparing(Student::getAge));
        System.out.println("\n按年龄升序:");
        for (Student student : students) {
            System.out.println(student);
        }

        // 查找年龄最大的学生
        Student oldestStudent = Collections.max(students, Comparator.comparing(Student::getAge));
        System.out.println("\n年龄最大的学生:");
        System.out.println(oldestStudent);

        // 查找年龄最小的学生
        Student youngestStudent = Collections.min(students, Comparator.comparing(Student::getAge));
        System.out.println("\n年龄最小的学生:");
        System.out.println(youngestStudent);

        // 反转学生列表
        Collections.reverse(students);
        System.out.println("\n反转:");
        for (Student student : students) {
            System.out.println(student);
        }

        // 替换年龄最小的学生的信息（例如，替换为另一个学生）
        Collections.replaceAll(students, youngestStudent, new Student("005", "Eve", 20));
        System.out.println("\n替换:");
        for (Student student : students) {
            System.out.println(student);
        }

        // 填充学生列表（用特定学生填充）
        Collections.fill(students, new Student("006", "Fiona", 24));
        System.out.println("\n填充:");
        for (Student student : students) {
            System.out.println(student);
        }

        // 复制学生列表
        List<Student> copiedStudents = new ArrayList<>(students);
        Collections.copy(copiedStudents, students);
        System.out.println("\n复制:");
        for (Student student : copiedStudents) {
            System.out.println(student);
        }

        // 交换两个学生的位置,例如，将第一个和最后一个学生交换位置
        Collections.swap(students, 0, students.size() - 1);
        System.out.println("\n交换:");
        for (Student student : students) {
            System.out.println(student);
        }

        // 旋转学生列表,例如，将列表向右旋转2个位置
        Collections.rotate(students, 2);
        System.out.println("\n旋转:");
        for (Student student : students) {
            System.out.println(student);
        }

        // 随机打乱学生列表
        Collections.shuffle(students);
        System.out.println("\n随机打乱:");
        for (Student student : students) {
            System.out.println(student);
        }


        // 使用二分查找查找特定学生（按年龄排序后）
//        Student targetStudent = new Student("000", "Non-existent", 21); // 假设要查找年龄为21的学生
        Student targetStudent = new Student("000", "Non-existent", 27); // 假设要查找年龄为27的学生
        int index = Collections.binarySearch(students, targetStudent, Comparator.comparing(Student::getAge));
        if (index >= 0) {
            System.out.println("\n年龄是21的学生索引: " + index);
            System.out.println(students.get(index));
        } else {
            System.out.println("\n没有找到年龄是21的学生索引: " + (-index - 1));
        }
    }
}

3、效果

四、总结

Collections 类提供的方法大大简化了对集合的操作，通过合理的选择和使用这些方法，可以高效地实现各种集合处理逻辑。需要注意的是，某些方法（如排序和二分查找）对集合的状态（如排序状态）有要求，使用时需要确保满足这些要求，以避免异常或错误的结果。