Java compter l'apparition de chaque élément dans un tableau

Vous pouvez utiliser un MultiSet de Google Collections/Goyave ou un Sac de Apache Commons.

Si vous avez une collection au lieu d'un tableau, vous pouvez utiliser addAll() pour ajouter tout le contenu au-dessus de la structure de données, puis appliquer le count() méthode pour chaque valeur. Un SortedMultiSet ou SortedBag serait de vous donner les éléments dans un ordre défini.

Google Collections a en fait très pratique façons de le faire à partir de baies d'un SortedMultiset.

Avec java-8, vous pouvez le faire comme ceci:

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

De sortie:

name5 1
name4 1
name3 1
name2 2
name1 1

Ce qu'il fait est:

• Créer un Stream<String> du tableau d'origine
• Groupe de chaque élément de l'identité, résultant en une Map<String, List<String>>
• Pour chaque valeur de la clé de la paire, d'impression de la clé et de la taille de la liste

Si vous voulez obtenir un Map qui contient le nombre d'occurrences de chaque mot, il peut être fait en faisant:

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

Pour plus d'informations:

• Stream
• Collecteurs

Espère que cela aide! 🙂

J'ai écrit une solution pour que cette pratique moi-même. Il ne semble pas presque aussi génial que les autres réponses postées, mais je vais le poster quand même, et puis apprendre comment faire cela en utilisant les autres méthodes. Profitez d':

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

Il peut être fait d'une manière très simple à l'aide de collections
vous trouverez le code ci-dessous

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

Ici, la sortie sera comme
nom1 2
nom1 2
nom2 3
nom2 3
nom2 3

Afin d'éviter l'impression redondant utilisation des touches HashMap et obtenir votre sortie désirée

Vous pouvez le faire à l'aide de Matrices.le tri et la Récursivité. Le même vin, mais dans une autre bouteille....

import java.util.Arrays;

public class ArrayTest {
public static int mainCount=0;

public static void main(String[] args) {
    String prevItem = "";
    String[] array = {"name1","name1","name2","name2", "name2"};
    Arrays.sort(array);

    for(String item:array){
        if(! prevItem.equals(item)){
            mainCount = 0;
            countArray(array, 0, item);
            prevItem = item;
        }
    }
}

private static void countArray(String[] arr, int currentPos, String item) {
    if(currentPos == arr.length){
        System.out.println(item + " " +  mainCount);
        return;
    }
    else{
        if(arr[currentPos].toString().equals(item)){
            mainCount += 1;
        }
        countArray(arr, currentPos+1, item);
    }
  }
}

Il existe plusieurs méthodes qui peuvent aider, mais c'est l'un est à l'aide de la boucle.

import java.util.Arrays;
public class one_dimensional_for {
private static void count(int[] arr) {
Arrays.sort(arr);
int sum = 0, counter = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[0] == arr[arr.length - 1]) {
System.out.println(arr[0] + ": " + counter + " times");
break;
} else {
if (i == (arr.length - 1)) {
sum += arr[arr.length - 1];
counter++;
System.out.println((sum / counter) + " : " + counter
+ " times");
break;
} else {
if (arr[i] == arr[i + 1]) {
sum += arr[i];
counter++;
} else if (arr[i] != arr[i + 1]) {
sum += arr[i];
counter++;
System.out.println((sum / counter) + " : " + counter
+ " times");
sum = 0;
counter = 0;
}
}
}
}
}
public static void main(String[] args) {
int nums[] = { 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 5, 5, 6 };
count(nums);
}
}

vous pouvez trouver à l'aide de table de hachage avec une simple technique

public class HashMapExample {
public static void main(String[] args) {
stringArray();          
}
public static void stringArray()
{
String[] a = {"name1","name2","name3","name4", "name5"};
Map<String, String> hm = new HashMap<String, String>();
for(int i=0;i<a.length;i++)
{
String bl=(String)hm.get(a[i]);
if(bl==null)
{
hm.put(a[i],String.valueOf(1));
}else
{
String k=hm.get(a[i]);
int j=Integer.valueOf(k);
hm.put(a[i],String.valueOf(j+1));
}
}
//hm.entrySet();
System.out.println("map elements are "+hm.toString());
}
}

Vous pouvez utiliser la table de hachage, où Key est votre chaîne et de la valeur - temps.