如何计算列表中元素的出现次数

我有一个ArrayListJava的Collection类，如下所示：

ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");

如您所见，animals ArrayList包含3个bat元素和一个owl元素。我想知道Collection框架中是否有任何API返回出现次数，bat或者是否有另一种方法来确定出现次数。

我发现Google的Collection Multiset确实有一个API，该API返回一个元素出现的总数。但这仅与JDK 1.5兼容。我们的产品当前在JDK 1.6中，所以我不能使用它。

我很确定Collections中的静态频率方法会在这里派上用场：

int occurrences = Collections.frequency(animals, "bat");

无论如何，这就是我要做的。我很确定这是jdk 1.6。

在Java 8中：

Map<String, Long> counts =
    list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));

这表明，为什么按有效Java书中所述“ 通过其接口引用对象 ”很重要。

如果您对实现进行编码，并在代码中使用ArrayList，例如，在代码中使用了50个位置，那么当您找到一个很好的“ 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" ));
    }
}

OO原则在这里适用：继承，多态性，抽象，封装。

抱歉，没有简单的方法调用可以做到。不过，您要做的就是创建一个地图并用它计算频率。

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

Java中没有本机方法可以为您执行此操作。但是，您可以使用Apache Commons-Collections中的IterableUtils＃countMatches（）为您完成此操作。

实际上，Collections类有一个静态方法，称为：frequency（集合c，对象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"));

使用Streams的替代Java 8解决方案：

long count = animals.stream().filter(animal -> "bat".equals(animal)).count();

我想知道，为什么您不能在JDK 1.6中使用该Google的Collection API。会这样吗？我认为可以，不应该存在任何兼容性问题，因为它是为较低版本而构建的。如果是针对1.6构建的，而您正在运行1.5，情况将有所不同。

我在某个地方错了吗？

一种稍微有效的方法可能是

Map<String, AtomicInteger> instances = new HashMap<String, AtomicInteger>();

void add(String name) {
     AtomicInteger value = instances.get(name);
     if (value == null) 
        instances.put(name, new AtomicInteger(1));
     else
        value.incrementAndGet();
}

要直接从列表中获取对象的出现：

int noOfOccurs = Collections.frequency(animals, "bat");

要获得列表中的Object集合的出现，请重写Object类中的equals方法为：

@Override
public boolean equals(Object o){
    Animals e;
    if(!(o instanceof Animals)){
        return false;
    }else{
        e=(Animals)o;
        if(this.type==e.type()){
            return true;
        }
    }
    return false;
}

Animals(int type){
    this.type = type;
}

将Collections.frequency称为：

int noOfOccurs = Collections.frequency(animals, new Animals(1));

使用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}

您想要的是一个袋子-它就像一个集合，但也可以计算出现的次数。不幸的是，java Collections框架-很棒，因为它们没有Bag impl。为此，必须使用Apache Common Collection 链接文本

List<String> list = Arrays.asList("as", "asda", "asd", "urff", "dfkjds", "hfad", "asd", "qadasd", "as", "asda",
        "asd", "urff", "dfkjds", "hfad", "asd", "qadasd" + "as", "asda", "asd", "urff", "dfkjds", "hfad", "asd",
        "qadasd", "as", "asda", "asd", "urff", "dfkjds", "hfad", "asd", "qadasd");

方法1：

Set<String> set = new LinkedHashSet<>();
set.addAll(list);

for (String s : set) {

    System.out.println(s + " : " + Collections.frequency(list, s));
}

方法2：

int count = 1;
Map<String, Integer> map = new HashMap<>();
Set<String> set1 = new LinkedHashSet<>();
for (String s : list) {
    if (!set1.add(s)) {
        count = map.get(s) + 1;
    }
    map.put(s, count);
    count = 1;

}
System.out.println(map);

如果使用Eclipse Collections，则可以使用Bag。一个MutableBag可以从任何实现返回RichIterable调用toBag()。

MutableList<String> animals = Lists.mutable.with("bat", "owl", "bat", "bat");
MutableBag<String> bag = animals.toBag();
Assert.assertEquals(3, bag.occurrencesOf("bat"));
Assert.assertEquals(1, bag.occurrencesOf("owl"));

HashBagEclipse Collections中的实现由来支持MutableObjectIntMap。

注意：我是Eclipse Collections的提交者。

将arraylist的元素放在hashMap中以计算频率。

Java 8-另一种方法

String searched = "bat";
long n = IntStream.range(0, animals.size())
            .filter(i -> searched.equals(animals.get(i)))
            .count();

因此，以老式的方式进行并自己滚动：

Map<String, Integer> instances = new HashMap<String, Integer>();

void add(String name) {
     Integer value = instances.get(name);
     if (value == null) {
        value = new Integer(0);
        instances.put(name, value);
     }
     instances.put(name, value++);
}

如果您是我的ForEach DSL的用户，则可以通过Count查询来完成。

Count<String> query = Count.from(list);
for (Count<Foo> each: query) each.yield = "bat".equals(each.element);
int number = query.result();

我不想让这种情况变得更加困难，并且让它具有两个迭代器，我有一个具有LastName-> FirstName的HashMap。而且我的方法应该删除具有双重名字的项目。

public static void removeTheFirstNameDuplicates(HashMap<String, String> map)
{

    Iterator<Map.Entry<String, String>> iter = map.entrySet().iterator();
    Iterator<Map.Entry<String, String>> iter2 = map.entrySet().iterator();
    while(iter.hasNext())
    {
        Map.Entry<String, String> pair = iter.next();
        String name = pair.getValue();
        int i = 0;

        while(iter2.hasNext())
        {

            Map.Entry<String, String> nextPair = iter2.next();
            if (nextPair.getValue().equals(name))
                i++;
        }

        if (i > 1)
            iter.remove();

    }

}

List<String> lst = new ArrayList<String>();

lst.add("Ram");
lst.add("Ram");
lst.add("Shiv");
lst.add("Boss");

Map<String, Integer> mp = new HashMap<String, Integer>();

for (String string : lst) {

    if(mp.keySet().contains(string))
    {
        mp.put(string, mp.get(string)+1);

    }else
    {
        mp.put(string, 1);
    }
}

System.out.println("=mp="+mp);

输出：

=mp= {Ram=2, Boss=1, Shiv=1}

Map<String,Integer> hm = new HashMap<String, Integer>();
for(String i : animals) {
    Integer j = hm.get(i);
    hm.put(i,(j==null ? 1 : j+1));
}
for(Map.Entry<String, Integer> val : hm.entrySet()) {
    System.out.println(val.getKey()+" occurs : "+val.getValue()+" times");
}

package traversal;

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

public class Occurrance {
    static int count;

    public static void main(String[] args) {
        List<String> ls = new ArrayList<String>();
        ls.add("aa");
        ls.add("aa");
        ls.add("bb");
        ls.add("cc");
        ls.add("dd");
        ls.add("ee");
        ls.add("ee");
        ls.add("aa");
        ls.add("aa");

        for (int i = 0; i < ls.size(); i++) {
            if (ls.get(i) == "aa") {
                count = count + 1;
            }
        }
        System.out.println(count);
    }
}

输出4