Java Collections 类中方法详解

原创 于 2025-02-20 09:46:39 发布 · 1.1k 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

java.util.Collections 类

java.util.Collections 类是 Java 集合框架的一个工具类，它包含一系列静态方法，用于操作和处理各种类型的集合。 这些方法提供了对集合进行排序、查找、同步控制、创建只读集合等常见操作的便捷方式。 注意： Collections 类本身不能被实例化，它的所有方法都是静态的，可以直接通过类名调用。

一、 排序 (Sorting)

  1. sort(List<T> list)：

    • 作用： 对指定的 List 集合进行升序排序。

    • 要求： 列表中的元素必须实现 Comparable 接口，即具有自然顺序。 否则会抛出 ClassCastException。

    • 算法： 通常使用归并排序 (Merge Sort) 或 TimSort (一种混合排序算法，结合了归并排序和插入排序的优点)，具有较好的平均性能和最坏情况性能。

    • 示例：

      List<Integer> numbers = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 9));
Collections.sort(numbers);
System.out.println(numbers); // 输出：[1, 2, 5, 8, 9]

  2. sort(List<T> list, Comparator<? super T> c)：

    • 作用： 根据指定的比较器 (Comparator) 对 List 集合进行排序。

    • 要求： 列表中的元素不需要实现 Comparable 接口，可以使用自定义的比较器来定义排序规则。

    • 算法： 同样通常使用归并排序或 TimSort。

    • 示例：

      List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie", "David"));
Collections.sort(names, (s1, s2) -> s1.length() - s2.length()); // 根据字符串长度排序
System.out.println(names); // 输出：[Bob, Alice, David, Charlie]

二、 查找 (Searching)

  1. binarySearch(List<? extends Comparable<? super T>> list, T key)：

    • 作用： 使用二分查找算法在指定的 List 集合中查找指定的元素。

    • 要求：

      • 列表必须已排序（升序），否则结果不确定。
      • 列表中的元素必须实现 Comparable 接口，即具有自然顺序。

    • 返回值：

      • 如果找到元素，则返回元素的索引。
      • 如果没有找到元素，则返回 (-(insertion point) - 1)，其中 insertion point 是将元素插入到列表中以保持排序顺序的索引。

    • 示例：

      List<Integer> numbers = Arrays.asList(1, 2, 5, 8, 9); // 必须已排序
int index = Collections.binarySearch(numbers, 5);
System.out.println("Index of 5: " + index); // 输出：Index of 5: 2

int notFound = Collections.binarySearch(numbers, 6);
System.out.println("Index of 6: " + notFound); // 输出：Index of 6: -4

  2. binarySearch(List<? extends T> list, T key, Comparator<? super T> c)：

    • 作用： 使用二分查找算法在指定的 List 集合中查找指定的元素，使用指定的比较器进行比较。

    • 要求： 列表必须已排序（按照比较器的规则），否则结果不确定。

    • 返回值： 与 binarySearch(List<? extends Comparable<? super T>> list, T key) 相同。

    • 示例：

      List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David"); // 必须按照比较器的规则排序
Collections.sort(names, (s1, s2) -> s1.length() - s2.length()); // 先按长度排序
int index = Collections.binarySearch(names, "David", (s1, s2) -> s1.length() - s2.length());
System.out.println("Index of David: " + index); // 输出：Index of David: 2

三、 最大值和最小值 (Maximum and Minimum)

  1. max(Collection<? extends T> coll)：

    • 作用： 返回指定集合中的最大元素。

    • 要求： 集合中的元素必须实现 Comparable 接口，即具有自然顺序。

    • 示例：

      List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
int max = Collections.max(numbers);
System.out.println("Max: " + max); // 输出：Max: 9

  2. min(Collection<? extends T> coll)：

    • 作用： 返回指定集合中的最小元素。

    • 要求： 集合中的元素必须实现 Comparable 接口，即具有自然顺序。

    • 示例：

      List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
int min = Collections.min(numbers);
System.out.println("Min: " + min); // 输出：Min: 1

  3. max(Collection<? extends T> coll, Comparator<? super T> comp)：

    • 作用： 返回指定集合中的最大元素，使用指定的比较器进行比较。

    • 要求： 不需要实现 Comparable接口。

    • 示例：

      List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
String longestName = Collections.max(names, (s1, s2) -> s1.length() - s2.length());
System.out.println("Longest name: " + longestName); // 输出：Longest name: Charlie

  4. min(Collection<? extends T> coll, Comparator<? super T> comp)：

    • 作用： 返回指定集合中的最小元素，使用指定的比较器进行比较。

    • 要求： 不需要实现 Comparable接口。

    • 示例：

      List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
String shortestName = Collections.min(names, (s1, s2) -> s1.length() - s2.length());
System.out.println("Shortest name: " + shortestName); // 输出：Shortest name: Bob

四、 反转 (Reversing)

  1. reverse(List<?> list)：

    • 作用： 反转指定 List 集合中元素的顺序。

    • 示例：

      List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Collections.reverse(numbers);
System.out.println(numbers); // 输出：[5, 4, 3, 2, 1]

五、 随机排序 (Shuffling)

  1. shuffle(List<?> list)：

    • 作用： 使用默认随机源随机排列指定的 List 集合。

    • 示例：

      List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Collections.shuffle(numbers);
System.out.println(numbers); // 输出：[随机排列后的结果，例如：[3, 1, 5, 2, 4]]

  2. shuffle(List<?> list, Random rnd)：

    • 作用： 使用指定的随机源随机排列指定的 List 集合。

    • 示例：

      List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Random random = new Random();
Collections.shuffle(numbers, random);
System.out.println(numbers); // 输出：[随机排列后的结果，例如：[2, 5, 1, 4, 3]]

六、 填充 (Filling)

  1. fill(List<? super T> list, T obj)：

    • 作用： 使用指定的对象替换指定 List 集合中的所有元素。

    • 示例：

      List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Collections.fill(numbers, 0);
System.out.println(numbers); // 输出：[0, 0, 0, 0, 0]

七、 复制 (Copying)

  1. copy(List<? super T> dest, List<? extends T> src)：

    • 作用： 将所有元素从源 List 集合复制到目标 List 集合。

    • 要求：

      • 目标列表的长度必须大于或等于源列表的长度，否则会抛出 IndexOutOfBoundsException。
      • 目标列表和源列表的元素类型必须兼容。

    • 示例：

      List<Integer> source = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> destination = new ArrayList<>(Arrays.asList(0, 0, 0, 0, 0)); // 长度必须 >= source.size()
Collections.copy(destination, source);
System.out.println(destination); // 输出：[1, 2, 3, 4, 5]

八、 交换 (Swapping)

  1. swap(List<?> list, int i, int j)：
    作用： 在指定列表中交换指定位置的元素。
List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Collections.swap(numbers, 0, 4);
System.out.println(numbers); // 输出：[5, 2, 3, 4, 1]

九、 频率 (Frequency)

  1. frequency(Collection<?> c, Object o)：
    作用： 返回集合中与指定对象相等的元素的数量。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Alice");
int frequency = Collections.frequency(names, "Alice");
System.out.println("Frequency of Alice: " + frequency); // 输出：Frequency of Alice: 2

十、 线程安全集合 (Synchronized Collections)

Collections 类提供了一组静态方法，用于将非线程安全的集合转换为线程安全的集合。 这些方法本质上是对集合的操作进行加锁，以实现线程安全。

  1. synchronizedCollection(Collection<T> c)：

    • 作用： 返回一个线程安全的 Collection。

    • 原理： 对 Collection 接口中的所有方法进行同步。

    • 示例：

      Collection<Integer> numbers = new ArrayList<>();
Collection<Integer> syncNumbers = Collections.synchronizedCollection(numbers); // 创建线程安全的 Collection

  2. synchronizedList(List<T> list)：

    • 作用： 返回一个线程安全的 List。

    • 原理： 对 List 接口中的所有方法进行同步。

    • 示例：

      List<Integer> numbers = new ArrayList<>();
List<Integer> syncNumbers = Collections.synchronizedList(numbers); // 创建线程安全的 List

  3. synchronizedSet(Set<T> s)：

    • 作用： 返回一个线程安全的 Set。

    • 原理： 对 Set 接口中的所有方法进行同步。

    • 示例：

      Set<Integer> numbers = new HashSet<>();
Set<Integer> syncNumbers = Collections.synchronizedSet(numbers); // 创建线程安全的 Set

  4. synchronizedMap(Map<K,V> m)：

    • 作用： 返回一个线程安全的 Map。

    • 原理： 对 Map 接口中的所有方法进行同步。

    • 示例：

      Map<String, Integer> scores = new HashMap<>();
Map<String, Integer> syncScores = Collections.synchronizedMap(scores); // 创建线程安全的 Map

注意事项：

  • 性能较低： synchronized 集合的性能较低，因为所有操作都需要获取锁。在高并发场景下，建议使用 java.util.concurrent 包提供的并发集合类（例如 ConcurrentHashMap, CopyOnWriteArrayList）。
  • 迭代： 即使使用了 synchronized 集合，在迭代集合时仍然需要进行同步，以避免 ConcurrentModificationException。 可以使用 synchronized 代码块或 synchronized 方法来保护迭代过程。

示例：线程安全的迭代

List<Integer> numbers = Collections.synchronizedList(new ArrayList<>());

synchronized (numbers) { // 同步代码块
    Iterator<Integer> iterator = numbers.iterator();
    while (iterator.hasNext()) {
        Integer number = iterator.next();
        // 处理 number
    }
}

十一、 不可修改的集合 (Unmodifiable Collections)

Collections 类提供了一组静态方法，用于创建不可修改的集合（只读集合）。 尝试修改这些集合会抛出 UnsupportedOperationException 异常。

  1. unmodifiableCollection(Collection<? extends T> c)：

    • 作用： 返回一个不可修改的 Collection。

  2. unmodifiableList(List<? extends T> list)：

    • 作用： 返回一个不可修改的 List。

  3. unmodifiableSet(Set<? extends T> s)：

    • 作用： 返回一个不可修改的 Set。

  4. unmodifiableSortedSet(SortedSet<T> s)：

  • 作用： 返回一个不可修改的 SortedSet。
  1. unmodifiableNavigableSet(NavigableSet<T> s)：
  • 作用: 返回一个不可修改的 NavigableSet。

  1. unmodifiableMap(Map<? extends K,? extends V> m)：

    • 作用： 返回一个不可修改的 Map。

  2. unmodifiableSortedMap(SortedMap<K, V> m)：

  • 作用： 返回一个不可修改的 SortedMap。
  1. unmodifiableNavigableMap(NavigableMap<K, V> m)：
  • 作用: 返回一个不可修改的 NavigableMap。

使用场景：

  • 保护集合数据： 防止外部代码修改集合中的数据。
  • 创建只读的配置对象： 例如，将应用程序的配置信息存储在一个 Map 中，并将其设置为不可修改的，以防止运行时被意外修改。

示例：

List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
List<String> unmodifiableNames = Collections.unmodifiableList(names);

// 尝试修改 unmodifiableNames 会抛出 UnsupportedOperationException
try {
    unmodifiableNames.add("David"); // 抛出 UnsupportedOperationException
} catch (UnsupportedOperationException e) {
    System.out.println("Caught exception: " + e);
}

// 修改 names 会影响 unmodifiableNames (因为 unmodifiableNames 只是一个视图)
names.add("David");
System.out.println(unmodifiableNames); // 输出：[Alice, Bob, Charlie, David]

注意事项：

  • 只读视图： unmodifiable 方法返回的集合只是一个只读视图，它仍然引用原始集合。 如果原始集合发生了改变，那么只读视图也会反映这些改变。
  • 浅拷贝： unmodifiable 方法返回的只是集合的 浅拷贝
java Collections使用方法与详细分析
一片冰心
05-22 1270
Collections 此类仅由对集合进行操作或返回集合的静态方法组成。 用例 import java.util.*; public class Test { public static void main(String[] args) { ArrayList<Integer> arrayList = new ArrayList<>(); arrayList.add(12); arrayList.add(10); .
【JAVA】Collections类 详解
weixin_37559642的博客
08-15 1927
Collections类 详解
黑马程序员全套Java教程_Java基础教程_集合进阶之Collection
Chenhui98的博客
09-07 478
Collection集合概述：（1）是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素；（2）JDK不提供此接口的任何直接实现，他提供更具体的子接口（如Set和List）实现。创建Collection集合的对象：（1）多态的方式；（2）具体的实现类ArrayList。//创建Collection集合对象//添加元素：public boolean add(E e)//输出集合对象}
Java Collections工具类：常用方法与技巧
yokeyhui的博客
01-02 1669
类中提供的静态工厂方法，分别用于创建只包含一个元素的不可变集合和列表。这些方法在需要返回一个只含有一个元素的集合或列表时非常有用，因为它们提供了类型安全的不可变对象，而不需要手动创建这样的集合或列表。是一个提供静态方法的实用程序类，用于操作或返回集合（特别是列表和集），而不需要创建这些集合的新实例。方法在已排序的列表中执行二分查找，返回指定元素的索引。方法用于使用指定的元素替换列表中的一系列元素。方法则用于从一个集合中移除所有存在于另一个集合中的元素。这个方法会直接修改传入的列表，不会返回新的列表。
Java Collections常用方法
书香水墨
03-20 403
方法 描述 static <T> boolean addAll(Collection<? super T> c, T… elements) 将所有指定的元素添加到指定的集合中。 static <T> Queue<T> asLifoQueue(Deque<T> deque) 以后进Deque先出（Lifo）的形式 返回a...
java中Collections.sort排序详解
08-25
Java中的Collections.sort排序是Java.util.Collections类中的一个静态方法，用于对列表进行排序。下面将详细介绍Collections.sort排序的使用和实现机制。 Collections.sort()方法的使用： Collections.sort()方法...
详解Java中Collections.sort排序
08-30
在Java编程语言中，`Collections.sort()`方法是一个非常重要的工具，它用于对集合中的元素进行排序。这个方法主要应用于`List`接口的实现类，如`ArrayList`和`LinkedList`等。`Collections.sort()`有两种主要的排序...
详解java中的Collections类
09-02
Java中的Collections类是Java集合框架的核心组件之一，它提供了对各种集合进行操作的静态方法，如排序、填充、反转等。Collections类位于`java.util`包下，因此在使用Collections时，通常需要在文件开头引入该包：`...
Java操作集合工具类Collections使用详解
08-25
Java操作集合工具类Collections使用详解 Java操作集合工具类Collections是Java语言中一个非常重要的工具类，主要用于操作Set、List和Map等集合。Collections工具类提供了大量方法对集合元素进行排序、查询和修改等...
JAVA集合Collection常用方法详解
weixin_65752158的博客
07-09 3609
提到集合就不得不提一下数组，好多集合底层都是依赖于数组的实现。数组一旦初始化后，长度就确定了，存储数据对象不能达到动态扩展，其次数组存储元素不便于对数组进行添加、修改、删除操作，而且数组可以存储重复元素。这个时候集合对作用显现出来了。集合分为Collection和Map两种体系。下面先介绍Collection的集合类的继承树如下图所示：单列集合只能一次添加一个数据双列集合可以一次添加2个数据。
Java中的Collections类中的一些常用方法
2402_83919997的博客
08-04 522
在Java中，Collections类是一个提供操作或返回集合的方法的实用类。它包含了一系列静态方法来操作或返回集合，比如排序、搜索和同步化等。这里我为大家介绍一下该类的一些常用方法，并通过示例来展示它们的使用。
Java - Collection
热门推荐
itlwc
08-21 4万+
collection层次结构 理论 集合中存放的依然是对象的引用而不是对象 集合中只能放置对象的引用,不能放置原生数据类型, 我们需要使用原生数据类型的封装类才能加入到集合中 集合中放置的都是Object类型,因此取出来的只能是Object类型 List称为序列 List接口用户可以对列表中每个元素的插入位置进行精确地控制 List索引是从0开始 允许重复的元素
Java-Collections 的几个常用方法
BLOG OF PETERMAOSX.
08-29 645
package com.company; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class CollectionsDemo { public static void main(String[] args){ List<Integ...
java里Collections常用方法示例
weixin_30432179的博客
06-30 307
package test;import java.util.ArrayList;import java.util.Collections;import java.util.List;public class CollectionsDemo001 { public static void main(String[] args) { List<String> list ...
java collections 用法_Java中Collections类详细用法
weixin_29268267的博客
02-13 2870
1、sort(Collection)方法的使用(含义：对集合进行排序)。例：对已知集合c进行排序？public class Practice {public static void main(String[] args){List c = new ArrayList();c.add("l");c.add("o");c.add("v");c.add("e");System.out.println(c...
JAVA Collections常用方法
wu_lai_314的专栏
03-19 3140
//仅作为学习笔记 /* 集合框架的工具类 Collections： */ import java.util.*; class Test { public static void main(String [] args) { List ls = new ArrayList(); ls.add("aaa"); ls.add("afs"); ls.add
Java中Collections工具类的常用方法
jl08133341的博客
05-13 275
1.addAll public static <T> boolean addAll(Collection<T> c, T ... elements)：往集合中添加一些元素。 2.sort public static <T> void sort(List<T> list)：将集合中元素按照默认规则排序（升序）。 注意：sort(list)有使用前提：被排序的集合元素必须实现了Comparable接口，重写接口中的compareTo方法定义排序的规则；Com
Collections 工具类常见方法
Harrytsz的博客
10-12 488
Collections 工具类常用方法 排序 查找,替换操作 同步控制(不推荐，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合) 排序操作 void reverse(List list)//反转 void shuffle(List list)//随机排序 void sort(List list)//按自然排序的升序排序 void sort(List list, Com...
Java的Collections类
a1013552415的博客
05-20 648
只对sort方法举例，其他方法类似。 1.sort()方法：对集合进行排序（主要使用的方法） 第一种：Comparable 排序接口 若一个类实现了Comparable接口，就意味着“该类支持排序”。 假设“有一个List列表(或数组)，里面的元素是实现了Comparable接口的类”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。 此外，“实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(Tr
package exam; import java.util.Collections; import java.util.Iterator; import java.util.LinkedList; //调用接口，Compareble //需要给出指定类型参数 class Student implements Comparable<Student>{ int height; String name; //构造方法 public Student (int height,String name){ this.height=height; this.name=name; } //()内要写其他对象，重点 public int compareTo(Student other){ return Integer.compare(this.height,other.height); } } public class test8 { public static void main(String[] args) { //创建链表 LinkedList<Student> list = new LinkedList(); //添加学生 list.add(new Student(180, "chen")); list.add(new Student(175, "zhang")); list.add(new Student(190, "lin")); //排序方法名记住，格式如下 Collections.sort(list); //Iterator遍历list Iterator<Student>iterator= list.iterator(); //查找特定学生 Student st=new Student(190,"lin"); int index=Collections.binarySearch(list,st); if(index>0){ System.out.println("该生存在"+list.get(index)); } else{ System.out.println("不存在"); } } }
最新发布
07-10
### 题目重述 本题要求定义一个 `Student` 类，实现 `Comparable<Student>` 接口，并正确重写 `compareTo` 方法，以便可以使用 `Collections.sort()` 和 `Collections.binarySearch()` 对 `LinkedList<Student>` 进行排序和查找。 --- ### 详解 当前代码整体结构是正确的，但存在一些细节问题，可能导致运行结果不准确或不稳定。我们来逐步分析： #### ✅ 正确的部分： 1. `Student` 类实现了 `Comparable<Student>` 接口。 2. `compareTo` 方法基于 `height` 属性进行比较，逻辑正确。 3. 使用了 `Collections.sort(list)` 进行排序。 4. 使用了 `Collections.binarySearch(list, st)` 进行查找。 5. 使用了 `Iterator` 遍历链表（虽然在代码中未显示完整遍历过程）。 #### ❗存在问题： 1. **未遍历输出排序后的列表** - 虽然声明了 `Iterator<Student> iterator = list.iterator();`，但没有实际的 `while` 循环进行输出。 2. **`binarySearch` 结果判断错误** - 当 `index >= 0` 时才是“找到”，但原判断为 `if(index > 0)`，这将导致当目标元素位于索引 0 时被误判为“不存在”。 3. **缺少必要的 `toString()` 方法** - 在 `Student` 类中没有重写 `toString()`，因此打印对象时会输出类似 `exam.Student@xxxx` 的内容，建议加上。 --- ### 修改建议如下： ```java // Student类添加toString方法 @Override public String toString() { return "Student{name='" + name + "', height=" + height + "}"; } ``` ```java // 主方法中修改查找判断，并增加遍历输出 // 遍历输出排序后的学生 Iterator<Student> iterator = list.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } // 修改查找部分的判断 Student st = new Student(190, "lin"); int index = Collections.binarySearch(list, st); if (index >= 0) { // 修正为 >= 0 System.out.println("该生存在：" + list.get(index)); } else { System.out.println("不存在"); } ``` --- ### 知识点 1. **Comparable接口** - 实现该接口可让对象支持自然排序。 - 必须重写 `compareTo()` 方法。 2. **Collections.binarySearch** - 用于在有序集合中高效查找元素。 - 要求集合已排序，否则结果不确定。 3. **二分查找的前提条件** - 数据必须有序。 - 否则不能保证查找结果的准确性。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冰糖心书房

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值