Java zählt das Vorkommen jedes Elements in einem Array

Gibt es eine Methode zum Zählen des Vorkommens jedes Elements in einem Array?

Nehmen wir an, ich habe:

String[] array = {"name1","name2","name3","name4", "name5"};

Hier wird die Ausgabe sein:

name1 1
name2 1
name3 1
name4 1
name5 1

und wenn ich habe:

String[] array = {"name1","name1","name2","name2", "name2"};

Die Ausgabe wäre:

name1 2
name2 3

Die Ausgabe hier dient nur dazu, das erwartete Ergebnis zu demonstrieren.

List asList = Arrays.asList(array);
Set<String> mySet = new HashSet<String>(asList);

for(String s: mySet){
 System.out.println(s + " " + Collections.frequency(asList,s));
}

Mit Java-8 können Sie es so machen:

String[] array = {"name1","name2","name3","name4", "name5", "name2"};
Arrays.stream(array)
      .collect(Collectors.groupingBy(s -> s))
      .forEach((k, v) -> System.out.println(k+" "+v.size()));

Ausgabe:

name5 1
name4 1
name3 1
name2 2
name1 1

Was es tut, ist:

• Ein … kreieren Stream<String> aus dem ursprünglichen Array
• Gruppieren Sie jedes Element nach Identität, was zu a führt Map<String, List<String>>
• Geben Sie für jedes Schlüsselwertpaar den Schlüssel und die Größe der Liste aus

Wenn Sie eine bekommen möchten Map die die Anzahl der Vorkommen für jedes Wort enthält, kann Folgendes getan werden:

Map<String, Long> map = Arrays.stream(array)
    .collect(Collectors.groupingBy(s -> s, Collectors.counting()));

Für weitere Informationen:

• Stream
• Collectors

Ich hoffe es hilft! 🙂

Sie könnten eine verwenden MultiSet aus Google Collections/Guava oder a Bag von ApacheCommons.

Wenn Sie anstelle eines Arrays eine Sammlung haben, können Sie verwenden addAll() um den gesamten Inhalt zu der obigen Datenstruktur hinzuzufügen, und wenden Sie dann die an count() Methode zu jedem Wert. EIN SortedMultiSet oder SortedBag würde Ihnen die Artikel in einer definierten Reihenfolge geben.

Google Collections bietet tatsächlich sehr bequeme Möglichkeiten, von Arrays zu a zu wechseln SortedMultiset.

Ich habe eine Lösung dafür geschrieben, um mich selbst zu üben. Es scheint nicht annähernd so großartig zu sein wie die anderen geposteten Antworten, aber ich werde es trotzdem posten und dann lernen, wie man dies auch mit den anderen Methoden macht. Genießen:

public static Integer[] countItems(String[] arr)
{
    List<Integer> itemCount = new ArrayList<Integer>();
    Integer counter = 0;
    String lastItem = arr[0];

    for(int i = 0; i < arr.length; i++)
    {
        if(arr[i].equals(lastItem))
        {
            counter++;
        }
        else
        {
            itemCount.add(counter);
            counter = 1;
        }
        lastItem = arr[i];
    }
    itemCount.add(counter);

    return itemCount.toArray(new Integer[itemCount.size()]);
}

public static void main(String[] args)
{
    String[] array = {"name1","name1","name2","name2", "name2", "name3",
            "name1","name1","name2","name2", "name2", "name3"};
    Arrays.sort(array);
    Integer[] cArr = countItems(array);
    int num = 0;
    for(int i = 0; i < cArr.length; i++)
    {
        num += cArr[i]-1;
        System.out.println(array[num] + ": " + cArr[i].toString());
    }
}

Mit HashMap ist es ein Spaziergang im Park.

main(){
    String[] array ={"a","ab","a","abc","abc","a","ab","ab","a"};
    Map<String,Integer> hm = new HashMap();

    for(String x:array){

        if(!hm.containsKey(x)){
            hm.put(x,1);
        }else{
            hm.put(x, hm.get(x)+1);
        }
    }
    System.out.println(hm);
}

Ich würde eine Hashtabelle verwenden, bei der der Schlüssel das Element des Arrays (hier Zeichenfolge) und den Wert eine ganze Zahl enthält.

Gehen Sie dann die Liste durch und tun Sie Folgendes:

for(String s:array){
if(hash.containsKey(s)){
  Integer i = hash.get(s);
  i++;
}else{
  hash.put(s, new Interger(1));
}

Dies kann auf sehr einfache Weise mit Sammlungen erfolgen. Finden Sie den Code unten

String[] array = {"name1","name1","name2","name2", "name2"};
List<String> sampleList=(List<String>) Arrays.asList(array);
for(String inpt:array){
int frequency=Collections.frequency(sampleList,inpt);
System.out.println(inpt+" "+frequency);
}

Hier sieht die Ausgabe wie folgt aus: name1 2 name1 2 name2 3 name2 3 name2 3

Um das Drucken redundanter Schlüssel zu vermeiden, verwenden Sie HashMap und erhalten Sie die gewünschte Ausgabe