So zählen Sie die Anzahl der Vorkommen eines Elements in einer Liste

Ich habe eine ArrayList, eine Collection-Klasse von Java, wie folgt:

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

Wie Sie sehen können, animals ArrayListbesteht das aus 3 batElementen und einem owlElement. Ich habe mich gefragt, ob es im Collection-Framework eine API gibt, die die Anzahl der batVorkommen zurückgibt, oder ob es eine andere Möglichkeit gibt, die Anzahl der Vorkommen zu bestimmen.

Ich habe festgestellt, dass die Google-Sammlung Multisetüber eine API verfügt, die die Gesamtzahl der Vorkommen eines Elements zurückgibt. Das ist aber nur mit JDK 1.5 kompatibel. Unser Produkt befindet sich derzeit in JDK 1.6, daher kann ich es nicht verwenden.

Ich bin mir ziemlich sicher, dass die statische Frequenzmethode in Sammlungen hier nützlich sein würde:

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

So würde ich es sowieso machen. Ich bin mir ziemlich sicher, dass dies JDK 1.6 ist.

In Java 8:

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

Dies zeigt, warum es wichtig ist, " Objekte über ihre Schnittstellen zu referenzieren ", wie im Buch " Effektives Java " beschrieben .

Wenn Sie für die Implementierung codieren und ArrayList an beispielsweise 50 Stellen in Ihrem Code verwenden und eine gute "List" -Implementierung finden, die die Elemente zählt, müssen Sie alle diese 50 Stellen ändern, und wahrscheinlich müssen Sie dies tun Brechen Sie Ihren Code (wenn er nur von Ihnen verwendet wird, gibt es keine große Sache, aber wenn er von jemand anderem verwendet wird, brechen Sie auch dessen Code)

Durch Programmieren auf die Schnittstelle können Sie diese 50 Stellen unverändert lassen und die Implementierung von ArrayList in "CountItemsList" (zum Beispiel) oder eine andere Klasse ersetzen.

Im Folgenden finden Sie ein sehr einfaches Beispiel dafür, wie dies geschrieben werden könnte. Dies ist nur ein Beispiel, eine produktionsreife Liste wäre viel komplizierter.

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

Hier angewandte OO-Prinzipien: Vererbung, Polymorphismus, Abstraktion, Kapselung.

Leider gibt es keinen einfachen Methodenaufruf, der dies ermöglicht. Alles, was Sie tun müssen, ist eine Karte zu erstellen und die Häufigkeit damit zu zählen.

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

In Java gibt es keine native Methode, um dies für Sie zu tun. Sie können jedoch IterableUtils # countMatches () aus Apache Commons-Collections verwenden, um dies für Sie zu tun.

Tatsächlich verfügt die Collections-Klasse über eine statische Methode namens: Frequency (Collection c, Object o), die die Anzahl der Vorkommen des gesuchten Elements zurückgibt. Dies funktioniert übrigens perfekt für Sie:

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

Ich frage mich, warum Sie die Google Collection-API nicht mit JDK 1.6 verwenden können. Sagt es so? Ich denke, Sie können, es sollte keine Kompatibilitätsprobleme geben, da es für eine niedrigere Version gebaut wurde. Der Fall wäre anders gewesen, wenn das für 1.6 erstellt worden wäre und Sie 1.5 ausführen.

Liege ich irgendwo falsch

Alternative Java 8- Lösung mit Streams :

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

Ein etwas effizienterer Ansatz könnte sein

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

So rufen Sie die Vorkommen des Objekts direkt aus der Liste ab:

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

Überschreiben Sie die equals-Methode in der Object-Klasse wie folgt, um das Auftreten der Object-Auflistung in der Liste zu ermitteln:

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

Rufen Sie die Collections.frequency auf als:

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

Einfache Methode zum Ermitteln des Auftretens von Zeichenfolgenwerten in einem Array mithilfe von Java 8-Funktionen.

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

Ausgabe: {Katze = 2, Ziege = 1, Kuh = 1, Kuh = 1, Hund = 1}

Sie können feststellen, dass "Cow" und cow nicht als dieselbe Zeichenfolge betrachtet werden. Verwenden Sie .toLowerCase (), falls Sie dies unter derselben Anzahl erforderlich gemacht haben. Bitte finden Sie das Snippet unten für das gleiche.

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

Ausgabe: {Katze = 2, Kuh = 2, Ziege = 1, Hund = 1}

Was Sie wollen, ist eine Tasche - die wie ein Set ist, aber auch die Anzahl der Vorkommen zählt. Leider ist das Java Collections Framework - großartig, da sie kein Bag Impl haben. Dazu muss der Linktext Apache Common Collection verwendet werden

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

Methode 1:

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

for (String s : set) {

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

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

Wenn Sie Eclipse-Sammlungen verwenden , können Sie a verwenden Bag. A MutableBagkann von jeder Implementierung von RichIterableper Aufruf zurückgegeben werden 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"));

Die HashBagImplementierung in Eclipse Collections wird durch a unterstützt MutableObjectIntMap.

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen.

Fügen Sie die Elemente der Arrayliste in die HashMap ein, um die Häufigkeit zu zählen.

Java 8 - eine andere Methode

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

Also mach es auf die altmodische Art und roll deine eigene:

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

Wenn Sie ein Benutzer von ForEach DSL sind , kann dies mit einer CountAbfrage erfolgen.

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

Ich wollte diesen Fall nicht schwieriger machen und machte es mit zwei Iteratoren. Ich habe eine HashMap mit Nachname -> Vorname. Und meine Methode sollte Elemente mit dem doppelten Vornamen löschen.

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

Ausgabe:

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

Ausgabe: 4