Как посчитать количество вхождений элемента в список

У меня ArrayListесть класс коллекции Java, следующим образом:

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

Как видите, animals ArrayListсостоит из 3 batэлементов и одного owlэлемента. Мне было интересно, есть ли какой-либо API в структуре Collection, который возвращает количество batвхождений или есть другой способ определить количество вхождений.

Я обнаружил, что в Google Collection Multisetесть API, который возвращает общее количество вхождений элемента. Но это совместимо только с JDK 1.5. Наш продукт в настоящее время находится в JDK 1.6, поэтому я не могу его использовать.

Я уверен, что статический частотный метод в Коллекциях пригодится здесь:

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

Применяемые здесь ОО-принципы: наследование, полиморфизм, абстракция, инкапсуляция.

К сожалению, нет простого вызова метода, который может это сделать. Все, что вам нужно сделать, это создать карту и рассчитывать частоту с ней.

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 нет нативного метода сделать это за вас. Однако вы можете использовать IterableUtils # countMatches () из Apache Commons-Collections, чтобы сделать это за вас.

На самом деле, класс Collections имеет статический метод с именем : quency (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"));

Альтернативное решение Java 8 с использованием Streams :

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

Интересно, почему вы не можете использовать этот API Google Collection с JDK 1.6. Так ли это? Я думаю, что вы можете, не должно быть никаких проблем с совместимостью, так как он создан для более низкой версии. Случай был бы другим, если бы он был построен для 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 в списке, переопределите метод equals в классе Object следующим образом:

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

Вывод: {Кошка = 2, Коза = 1, Корова = 1, Корова = 1, Собака = 1}

Вы можете заметить, что «Корова» и «корова» не считаются одной и той же строкой, и если вам требуется ее при одном и том же значении, используйте .toLowerCase (). Пожалуйста, найдите фрагмент ниже для того же.

Map<String, Long> couterMap = duplicateList.stream().collect(Collectors.groupingBy(e -> e.toString().toLowerCase(),Collectors.counting()));

Вывод: {кошка = 2, корова = 2, коза = 1, собака = 1}

То, что вы хотите, - это сумка, которая похожа на набор, но при этом подсчитывает количество случаев. К сожалению, фреймворк java Collections - великолепен, так как у него нет пакета Bag. Для этого нужно использовать текст ссылки 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. A 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"));

HashBagРеализация в Eclipse , Коллекции подкреплена MutableObjectIntMap.

Примечание: я являюсь коммиттером для Eclipse Collections.

Поместите элементы массива в 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();

Я не хотел усложнять этот случай и сделал это с двумя итераторами. У меня есть HashMap с LastName -> FirstName. И мой метод должен удалить элементы с указателем FirstName.

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