我有一个Java的集合类ArrayList，具体如下:
ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
你可以看到，animals ArrayList 包含了3个 bat 元素和一个 owl 元素。我想知道在 Collection 框架中是否有返回 bat 出现次数的 API，或者是否有其他方法来确定出现次数。
我发现谷歌的 Collection Multiset 确实有一个 API 可以返回一个元素的总出现次数。但这只适用于 JDK 1.5。我们的产品目前使用的是 JDK 1.6，所以我不能使用它。
我非常确定Collections中的静态frequency方法在这里会很有用：
int occurrences = Collections.frequency(animals, "bat");
这就是我会做的方式。我非常确定这是纯粹的jdk 1.6。
在Java 8中:
Map<String, Long> counts =
list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
Collections.frequency()更好？看起来可读性更差。 - rozina使用流(Streams)的另一种Java 8解决方案:
long count = animals.stream().filter(animal -> "bat".equals(animal)).count();
"bat"::equals。 - Unmitigated这表明了为什么要像Effective Java书中所描述的那样，"通过接口引用对象"是很重要的。
如果你按照实现方式来编码，在代码中使用ArrayList，当你找到一个好的“List”实现，它会计算项目数时，你将不得不更改这50个地方，并且可能会导致你的代码出错（如果只被你使用没有太大关系，但如果其他人在使用，你还会破坏他们的代码）
通过编程接口方法，你可以让这些50个地方保持不变，并将ArrayList的实现替换为"CountItemsList"（例如）或其他类。
下面是一个非常基本的示例，说明如何编写此代码。这只是一个示例，生产就绪的列表会复杂得多。
import java.util.*;
public class CountItemsList<E> extends ArrayList<E> {
// This is private. It is not visible from outside.
private Map<E,Integer> count = new HashMap<E,Integer>();
// There are several entry points to this class
// this is just to show one of them.
public boolean add( E element ) {
if( !count.containsKey( element ) ){
count.put( element, 1 );
} else {
count.put( element, count.get( element ) + 1 );
}
return super.add( element );
}
// This method belongs to CountItemList interface ( or class )
// to used you have to cast.
public int getCount( E element ) {
if( ! count.containsKey( element ) ) {
return 0;
}
return count.get( element );
}
public static void main( String [] args ) {
List<String> animals = new CountItemsList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
System.out.println( (( CountItemsList<String> )animals).getCount( "bat" ));
}
}
应用了面向对象编程原则：继承、多态、抽象、封装。
很抱歉，没有简单的方法可以完成它。不过你需要做的是创建一个映射表并使用它来计算频率。
HashMap<String,int> frequencymap = new HashMap<String,int>();
foreach(String a in animals) {
if(frequencymap.containsKey(a)) {
frequencymap.put(a, frequencymap.get(a)+1);
}
else{ frequencymap.put(a, 1); }
}
为了实现这一目标，可以采用以下几种方法：
返回单个元素出现次数的方法：
Collections.frequency(animals, "bat");
Java Stream:
过滤器
animals.stream().filter("bat"::equals).count();
只需迭代列表
public static long manually(Collection<?> c, Object o){
int count = 0;
for(Object e : c)
if(e.equals(o))
count++;
return count;
}
创建频率图的方法：
Map<String, Long> counts =
animals.stream()
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
Map<String, Long> map = new HashMap<>();
c.forEach(e -> map.merge(e, 1L, Long::sum));
手动地
Map<String, Integer> mp = new HashMap<>();
animals.forEach(animal -> mp.compute(animal, (k, v) -> (v == null) ? 1 : v + 1));
所有方法的运行示例：
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
public class Frequency {
public static int frequency(Collection<?> c, Object o){
return Collections.frequency(c, o);
}
public static long filter(Collection<?> c, Object o){
return c.stream().filter(o::equals).count();
}
public static long manually(Collection<?> c, Object o){
int count = 0;
for(Object e : c)
if(e.equals(o))
count++;
return count;
}
public static Map<?, Long> mapGroupBy(Collection<?> c){
return c.stream()
.collect(Collectors.groupingBy(Function.identity() , Collectors.counting()));
}
public static Map<Object, Long> mapMerge(Collection<?> c){
Map<Object, Long> map = new HashMap<>();
c.forEach(e -> map.merge(e, 1L, Long::sum));
return map;
}
public static Map<Object, Long> manualMap(Collection<?> c){
Map<Object, Long> map = new HashMap<>();
c.forEach(e -> map.compute(e, (k, v) -> (v == null) ? 1 : v + 1));
return map;
}
public static void main(String[] args){
List<String> animals = new ArrayList<>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
System.out.println(frequency(animals, "bat"));
System.out.println(filter(animals,"bat"));
System.out.println(manually(animals,"bat"));
mapGroupBy(animals).forEach((k, v) -> System.out.println(k + " -> "+v));
mapMerge(animals).forEach((k, v) -> System.out.println(k + " -> "+v));
manualMap(animals).forEach((k, v) -> System.out.println(k + " -> "+v));
}
}
方法的名称应该反映出这些方法正在做什么，但是我使用名称来反映所使用的方法（鉴于当前环境可以接受）。
Java中没有原生方法来为您执行此操作。 但是，您可以使用Apache Commons-Collections中的IterableUtils＃countMatches()来为您执行此操作。
使用Java 8功能查找数组中字符串值的出现方式的简单方法。
public void checkDuplicateOccurance() {
List<String> duplicateList = new ArrayList<String>();
duplicateList.add("Cat");
duplicateList.add("Dog");
duplicateList.add("Cat");
duplicateList.add("cow");
duplicateList.add("Cow");
duplicateList.add("Goat");
Map<String, Long> couterMap = duplicateList.stream().collect(Collectors.groupingBy(e -> e.toString(),Collectors.counting()));
System.out.println(couterMap);
}
输出：{Cat=2, Goat=1, Cow=1, cow=1, Dog=1}
您可以注意到"Cow"和"cow"被认为是不同的字符串，如果需要将其视为相同计数，请使用.toLowerCase()。请在下面找到相应的代码段。
Map<String, Long> couterMap = duplicateList.stream().collect(Collectors.groupingBy(e -> e.toString().toLowerCase(),Collectors.counting()));
输出：{猫=2，牛=2，山羊=1，狗=1}
toString()是不必要的。您可以这样做：duplicateList.stream().collect(Collectors.groupingBy(e -> e,Collectors.counting())); - Tad实际上，Collections类有一个名为frequency的静态方法(Collection c, Object o)，它返回你要搜索的元素出现的次数，顺便说一下，这对你来说非常完美:
ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
System.out.println("Freq of bat: "+Collections.frequency(animals, "bat"));
我想知道为什么你不能在JDK 1.6中使用Google的Collection API。它有这样的说明吗？我认为可以使用，因为它是为更低版本构建的，所以不应存在任何兼容性问题。如果它是为1.6构建的，而你却在运行1.5，那情况就会不同。
我哪里错了吗？