Java Collections 类中常用方法使用

凌冰_

于 2025-04-09 12:22:02 发布

阅读量444

点赞数 5

分类专栏： JAVA 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/hlx20080808/article/details/147090663

版权

JAVA 专栏收录该内容

82 篇文章

订阅专栏

一、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、操作学生信息如下：

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

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