Les plus courantes Chaîne dans ArrayList()

Ne pas réinventer la roue et utiliser les frequency méthode de la Collections classe:

public static int frequency(Collection<?> c, Object o)

Renvoie le nombre d'éléments dans la collection spécifiée égal à
l'objet spécifié. Plus formellement, renvoie le nombre d'éléments de e
dans la collection tel que (o == null ? e == null : o.est égal à(e)).

Si vous avez besoin de compter les occurrences de tous les éléments, l'utilisation d'une Carte et de la boucle intelligemment 🙂
Ou mettre votre liste dans un Ensemble et boucle sur chaque élément de l'ensemble avec les frequency méthode ci-dessus. HTH

MODIFIER /Java 8: Si vous avez envie d'un plus fonctionnel, Java 8 one-liner solution avec les lambdas, essayez:

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

Vous pouvez faire un HashMap<String,Integer>. Si la Chaîne est déjà présente dans la carte, incrémenter sa clé par un, sinon, l'ajouter à la carte.

Par exemple:

put("someValue", 1);

Alors, supposons qu'elle est "someValue" encore une fois, vous pouvez le faire:

put("someValue", get("someValue") + 1);

Depuis le clé de "someValue" est 1, maintenant, quand vous la mettez, la clé sera de 2.

Après cela, vous pouvez facilement passer à travers la carte et d'en extraire le clé qui a le plus haut valeur.

^{je n'ai pas écrit une solution complète, essayez de construire un, si vous avez des problèmes de poster dans une autre question. La meilleure pratique est d'apprendre par vous-même.}

Comme par question, Spécialement juste pour passer le mot, pas le nombre de fois (c'est à dire la valeur de la clé).

String mostRepeatedWord 
    = list.stream()
          .collect(Collectors.groupingBy(w -> w, Collectors.counting()))
          .entrySet()
          .stream()
          .max(Comparator.comparing(Entry::getValue))
          .get()
          .getKey();

Si quelqu'un a besoin de trouver les plus populaires de d'habitude String[] tableau (à l'aide de Listes):

public String findPopular (String[] array) {
    List<String> list = Arrays.asList(array);
    Map<String, Integer> stringsCount = new HashMap<String, Integer>();
    for(String string: list)
    {
        if (string.length() > 0) {
            string = string.toLowerCase();
            Integer count = stringsCount.get(string);
            if(count == null) count = new Integer(0);
            count++;
            stringsCount.put(string,count);
        }
    }
    Map.Entry<String,Integer> mostRepeated = null;
    for(Map.Entry<String, Integer> e: stringsCount.entrySet())
    {
        if(mostRepeated == null || mostRepeated.getValue()<e.getValue())
            mostRepeated = e;
    }
    try {
        return mostRepeated.getKey();
    } catch (NullPointerException e) {
        System.out.println("Cannot find most popular value at the List. Maybe all strings are empty");
        return "";
    }

}

• cas de non-sensibles

Vous pouvez utiliser la Goyave est Multiset:

ArrayList<String> names = ...

//count names 
HashMultiset<String> namesCounts = HashMultiset.create(names);
Set<Multiset.Entry<String>> namesAndCounts = namesCounts.entrySet();

//find one most common
Multiset.Entry<String> maxNameByCount = Collections.max(namesAndCounts, Comparator.comparing(Multiset.Entry::getCount));

//pick all with the same number of occurrences
List<String> mostCommonNames = new ArrayList<>();
for (Multiset.Entry<String> nameAndCount : namesAndCounts) {
    if (nameAndCount.getCount() == maxNameByCount.getCount()) {
        mostCommonNames.add(nameAndCount.getElement());
    }
}

Avec cette méthode, si il n'y a plus d'un la plupart des éléments communs dans votre liste de tableaux, vous obtenez de retour ensemble d'entre eux en les ajoutant à une nouvelle liste de tableaux.

public static void main(String[] args) {

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

words.add("cat") ; 
words.add("dog") ; 
words.add("egg") ; 
words.add("chair") ; 
words.add("chair") ; 
words.add("chair") ; 
words.add("dog") ; 
words.add("dog") ;  

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

    for (String word : words) {  /* Counts the quantity of each 
                                      element */
        if (! count.containsKey(word)) {             
            count.put(word, 1 ) ; 
        }

        else {
            int value = count.get(word) ; 
            value++ ; 

            count.put(word, value) ;
        }       
    }

    List <String> mostCommons = new ArrayList<>() ; /* Max elements  */

    for ( Map.Entry<String,Integer> e : count.entrySet() ) {

        if (e.getValue() == Collections.max(count.values() )){
                            /* The max value of count  */

            mostCommons.add(e.getKey()) ;
        }   
    }

    System.out.println(mostCommons);

 }

}