Java中Collections.frequency方法解析(解析,方法,Java,Collections,frequency.......)

Collections.frequency用于统计集合中某元素出现次数，其依赖equals方法判断相等，处理自定义对象需重写equals和hashCode，性能为O(n)，适用于小到中型集合；对于大数据量或频繁查询场景，使用HashMap或Stream API构建频率映射更高效，可将查询时间降为O(1)。

java中collections.frequency方法解析

Collections.frequency

方法在Java中，说白了，就是用来统计某个特定对象在集合（

Collection

）中出现了多少次的工具。它提供了一个简洁的API，让我们不用自己写循环就能完成这个常见的计数任务。

解决方案

Java.util.Collections

类中的

frequency(Collection c, Object o)

方法，其核心功能就是遍历给定的集合

，然后使用

o.equals(element)

来判断集合中的每个元素

element

是否与目标对象

相等。每当找到一个相等的元素，计数器就会加一。最终，它返回这个计数器的值。

这个方法设计得非常直观。比如你有一个字符串列表，想知道“Apple”出现了几次，直接调用

Collections.frequency(myList, "Apple")

就行了。它会老老实实地从头到尾检查一遍列表里的每一个元素。

值得注意的是，它依赖于对象的

equals()

方法。如果你的集合里存的是自定义对象，而你又没有正确地重写

equals()

方法，那么

frequency

的结果可能就不是你想要的了，它可能会因为默认的引用比较而误判。另外，这个方法也能很好地处理

null

值，如果你的集合里有

null

，而你传入

null

作为目标对象，它也能准确地告诉你集合里有多少个

null

。

从性能角度看，

Collections.frequency

的时间复杂度是 O(n)，其中 n 是集合的大小。因为它需要遍历整个集合。对于小型或中型集合，这通常不是问题，但如果集合非常大，并且你需要频繁地查询不同元素的频率，那么可能需要考虑更高效的数据结构。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class FrequencyExample {
    public static void main(String[] args) {
        List fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Apple");
        fruits.add("Orange");
        fruits.add("Apple");
        fruits.add(null);
        fruits.add("Banana");
        fruits.add(null);

        // 统计 "Apple" 出现的次数
        int appleCount = Collections.frequency(fruits, "Apple");
        System.out.println("Apple 出现的次数: " + appleCount); // 输出 3

        // 统计 "Banana" 出现的次数
        int bananaCount = Collections.frequency(fruits, "Banana");
        System.out.println("Banana 出现的次数: " + bananaCount); // 输出 2

        // 统计 "Grape" 出现的次数 (不存在)
        int grapeCount = Collections.frequency(fruits, "Grape");
        System.out.println("Grape 出现的次数: " + grapeCount); // 输出 0

        // 统计 null 出现的次数
        int nullCount = Collections.frequency(fruits, null);
        System.out.println("null 出现的次数: " + nullCount); // 输出 2

        // 尝试统计一个不存在的自定义对象
        class MyObject {
            String name;
            MyObject(String name) { this.name = name; }
            // 没有重写 equals() 和 hashCode()
        }
        List myObjects = new ArrayList<>();
        myObjects.add(new MyObject("A"));
        myObjects.add(new MyObject("B"));
        myObjects.add(new MyObject("A"));
        int myObjectACount = Collections.frequency(myObjects, new MyObject("A"));
        System.out.println("MyObject(\"A\") 出现的次数 (未重写 equals): " + myObjectACount); // 输出 0，因为是不同对象引用
    }
}

Collections.frequency

与手动遍历计数有何区别？性能如何？

在我看来，

Collections.frequency

和我们自己写一个

for

循环去遍历集合然后计数，在本质上是做同一件事。主要的区别在于代码的简洁性和可读性。

手动遍历计数通常是这样的：

public static int countManually(List list, String target) {
    int count = 0;
    for (String item : list) {
        if (target == null ? item == null : target.equals(item)) {
            count++;
        }
    }
    return count;
}

而

Collections.frequency

则将这些细节封装起来，你只需要调用一个方法就行了。从开发者的角度来看，这无疑更优雅，也减少了出错的可能性，毕竟标准库的方法经过了充分的测试。

至于性能，坦白说，对于大多数日常应用场景，两者的差异微乎其微，几乎可以忽略不计。它们都是 O(n) 的时间复杂度，这意味着它们的执行时间会随着集合大小的线性增长。

Collections.frequency

内部也是一个循环，只不过是Java标准库帮你写的。理论上，方法调用会有一些轻微的开销，但现代JVM的优化能力非常强，很多时候这种差异会被即时编译（JIT）优化掉。

我个人更倾向于使用

Collections.frequency

，因为它更符合“使用标准库提供的功能”这一最佳实践。它让代码意图更清晰，也避免了重复造轮子。除非你真的遇到了性能瓶颈，并且通过分析器（profiler）确认

Collections.frequency

是瓶颈所在，否则真的没必要去手动实现。大多数时候，过早的优化反而会牺牲代码的可读性和维护性。

处理 null 值或自定义对象时，

Collections.frequency

有什么注意事项？

处理

null

值时，

Collections.frequency

的行为非常明确且符合预期。如果你要查找的对象是

null

，它会遍历集合，统计所有

null

元素的数量。这在使用上很方便，比如你可能需要知道某个列表中有多少条数据是缺失的（用

null

表示）。

燕雀光年

一站式AI品牌设计平台，支持AI Logo设计、品牌VI设计、高端样机设计、AI营销设计等众多种功能

68 查看详情燕雀光年

List items = new ArrayList<>();
items.add("A");
items.add(null);
items.add("B");
items.add(null);
int nullCount = Collections.frequency(items, null); // nullCount 为 2
System.out.println("null 元素的数量: " + nullCount);

但是，当涉及到自定义对象时，事情就有点儿意思了，这里面的“坑”主要集中在

equals()

方法上。

Collections.frequency

内部是使用

o.equals(element)

来判断两个对象是否相等的。

如果你的自定义类没有重写

equals()

方法，它就会继承

Object

类的默认

equals()

方法，而这个方法比较的是对象的内存地址，也就是引用相等性（

obj1 == obj2

）。这意味着，即使两个自定义对象的所有属性值都一样，但如果它们是不同的实例（即内存地址不同），

Collections.frequency

也会认为它们不相等。

class Product {
    String name;
    double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }
    // 没有重写 equals()
}

List products = new ArrayList<>();
products.add(new Product("Laptop", 1200.0));
products.add(new Product("Mouse", 25.0));
products.add(new Product("Laptop", 1200.0)); // 另一个实例，但属性相同

// 尝试查找一个属性相同的 Product 对象
int laptopCount = Collections.frequency(products, new Product("Laptop", 1200.0));
System.out.println("Laptop 出现的次数 (未重写 equals): " + laptopCount); // 结果通常是 0

要让

Collections.frequency

正确地统计自定义对象，你必须在你的自定义类中重写

equals()

方法，并确保它实现了你期望的“相等”逻辑（通常是基于对象属性的比较）。同时，根据Java的约定，重写

equals()

方法时，也应该同时重写

hashCode()

方法，尽管

frequency

方法本身不直接使用

hashCode()

，但为了保持与其他基于哈希的集合（如

HashMap

HashSet

）的兼容性和正确性，这是非常重要的。

class ProductWithEquals {
    String name;
    double price;

    public ProductWithEquals(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ProductWithEquals that = (ProductWithEquals) o;
        return Double.compare(that.price, price) == 0 &&
               name.equals(that.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }
}

List productsWithEquals = new ArrayList<>();
productsWithEquals.add(new ProductWithEquals("Laptop", 1200.0));
productsWithEquals.add(new ProductWithEquals("Mouse", 25.0));
productsWithEquals.add(new ProductWithEquals("Laptop", 1200.0)); // 另一个实例，但属性相同

int laptopCountCorrect = Collections.frequency(productsWithEquals, new ProductWithEquals("Laptop", 1200.0));
System.out.println("Laptop 出现的次数 (重写 equals): " + laptopCountCorrect); // 结果现在是 2

所以，在使用

Collections.frequency

统计自定义对象时，切记检查你的

equals()

和

hashCode()

实现。这是避免意外结果的关键。

除了

Collections.frequency

，Java 还有哪些更高效的计数方法，尤其是在大数据量场景下？

Collections.frequency

对于一次性、小到中等规模的集合计数确实很方便。但正如前面提到的，它的 O(n) 复杂度意味着如果你需要对同一个大集合进行多次不同元素的频率查询，或者集合本身就非常庞大，那么每次都全量遍历一遍效率就会很低。在这种情况下，Java提供了更高效的替代方案。

我个人觉得，最常用的高效计数方法是使用

Map

来存储元素的频率。这种方法的核心思想是：遍历集合一次，将每个元素作为

Map

的键，其出现的次数作为

Map

的值。

import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.Arrays;
import java.util.function.Function;
import java.util.stream.Collectors;

// ... (假设有前面的 List fruits 集合)

public class EfficientCountingExample {
    public static void main(String[] args) {
        List fruits = Arrays.asList("Apple", "Banana", "Apple", "Orange", "Apple", null, "Banana", null);

        // 方法一：使用 HashMap 手动计数
        Map frequencyMap = new HashMap<>();
        for (String fruit : fruits) {
            frequencyMap.put(fruit, frequencyMap.getOrDefault(fruit, 0) + 1);
        }
        System.out.println("HashMap 手动计数结果: " + frequencyMap);
        // 之后查询 "Apple" 的次数就是 O(1)
        System.out.println("Apple 出现次数 (Map查询): " + frequencyMap.get("Apple"));

        // 方法二：使用 Java 8 Stream API
        // 注意：Stream API 默认不会将 null 作为 key，或者需要特殊处理
        Map streamFrequencyMap = fruits.stream()
                                                    .filter(f -> f != null) // 过滤掉 null，或者根据需求处理
                                                    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        System.out.println("Stream API 计数结果 (不含null): " + streamFrequencyMap);
        System.out.println("Apple 出现次数 (Stream Map查询): " + streamFrequencyMap.get("Apple"));

        // 如果要包含 null，可以这样处理：
        Map streamFrequencyMapWithNull = fruits.stream()
                .collect(Collectors.groupingBy(f -> f == null ? "NULL_KEY" : f, Collectors.counting()));
        System.out.println("Stream API 计数结果 (含null，用特殊键表示): " + streamFrequencyMapWithNull);
        System.out.println("null 出现次数 (Stream Map查询): " + streamFrequencyMapWithNull.get("NULL_KEY"));
    }
}

HashMap 手动计数：

优点：只需要遍历集合一次（O(n)），构建
```
Map
```
。之后对任何元素的频率查询都是 O(1) 的平均时间复杂度。对于需要多次查询不同元素频率的场景，这种方式的整体效率远高于多次调用
```
Collections.frequency
```
。
缺点：需要额外的内存来存储
```
Map
```
。

Java 8 Stream API：

优点：代码非常简洁和声明式，可读性高。同样只需要一次遍历。特别适合函数式编程风格。
缺点：对于非常小的集合，Stream API 的启动开销可能略大于传统循环。处理
```
null
```
值时需要稍微注意，比如上面例子中用
```
filter
```
过滤掉
```
null
```
，或者用一个特殊的字符串作为
```
null
```
的键。

选择建议：

Collections.frequency
：适用于你只需要查询一两个元素的频率，且集合规模不是特别大的情况。它代码最少，最直接。
HashMap
手动计数：当你需要对同一个集合进行多次频率查询，或者集合规模较大，对查询效率有较高要求时。这是性能和灵活性的良好平衡。
Java 8 Stream API：如果你喜欢函数式编程风格，并且项目已经在使用 Java 8 及以上版本，Stream API 是一个非常优雅的选择，它能用更少的代码实现与
```
HashMap
```
类似的高效计数。

在我看来，掌握这几种计数方法，能让你在不同的场景下灵活选择最合适的工具，写出更高效、更健壮的Java代码。很多时候，选择不是非黑即白，而是根据实际需求和上下文来做权衡。

以上就是Java中Collections.frequency方法解析的详细内容，更多请关注资源网其它相关文章！

相关标签： java 大数据 app 工具 ai apple 区别性能瓶颈标准库 Java jvm Object NULL for 封装 Filter 字符串循环数据结构继承 Collection map 对象大家都在看： Java中Map.Entry接口的常用方法 Java代码解析：计算整数各位数字之和如何用Java开发简单的问卷调查系统生成多模块 Java 项目中 JaCoCo 报告失败的解决方案 Java中对象比较的核心原则是什么

最近发表

热评文章

标签列表

网站分类

Java中Collections.frequency方法解析(解析,方法,Java,Collections,frequency.......)

相关阅读

Java匿名内部类在字节码中的命名解析(部类,字节,命名,解析,匿名.......)

解析Java匿名内部类的字节码命名机制(部类,字节,命名,解析,机制.......)

Java中自定义8位二进制数类Octet的加法实现教程(加法,自定义,二进制数,教程,Java.......)

生成 Java 多模块项目中的 JaCoCo 报告(生成,多模,报告,项目,Java.......)

Java 11+ 单文件源代码执行与传统类加载机制深度解析(源代码,深度,解析,加载,机制.......)

Java Checked Exception与Unchecked Exception区别(区别,Checked,Java,Unchecked,Exception.......)

最近发表

热评文章

标签列表

网站分类