Mot compte des fréquences de Java 8

La manière de compter la fréquence des mots de la Liste dans Java 8?

List <String> wordsList = Lists.newArrayList("hello", "bye", "ciao", "bye", "ciao");

Le résultat doit être: 

{ciao=2, hello=1, bye=2}
InformationsquelleAutor Mouna | 2015-03-18
  1. 75

    Je veux partager la solution que j'ai trouvé, car au début je m'attendais à utiliser la carte-et-réduire méthodes, mais c'était un peu différent.

    Map<String, Long> collect = 
        wordsList.stream().collect(groupingBy(Function.identity(), counting()));

    Ou pour les valeurs entières:

    Map<String, Integer> collect = 
        wordsList.stream().collect(groupingBy(Function.identity(), summingInt(e -> 1)));

    MODIFIER

    - Je ajouter de la façon de trier les carte en valeur: 

    LinkedHashMap<String, Long> countByWordSorted = collect.entrySet()
            .stream()
            .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
            .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    (v1, v2) -> {
                        throw new IllegalStateException();
                    },
                    LinkedHashMap::new
            ));
    InformationsquelleAutor Mouna
  2. 25

    (NOTE: Voir les modifications ci-dessous)

    Comme une alternative à Mounas répondre, ici, c'est une approche que le nombre de mots en parallèle:

    import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class ParallelWordCount
{
    public static void main(String[] args)
    {
        List<String> list = Arrays.asList(
            "hello", "bye", "ciao", "bye", "ciao");
        Map<String, Integer> counts = list.parallelStream().
            collect(Collectors.toConcurrentMap(
                w -> w, w -> 1, Integer::sum));
        System.out.println(counts);
    }
}

    MODIFIER En réponse à cette observation, j'ai couru un petit test avec JMH, en comparant les toConcurrentMap et la groupingByConcurrent approche, avec des entrées de la liste de tailles et aléatoire de mots de différentes longueurs. Ce test a suggéré que le toConcurrentMap approche a été plus rapide. Lorsque l'on considère la façon dont différents de ces approches sont "sous le capot", il est difficile de prévoir quelque chose comme ça.

    Comme une extension, sur la base d'autres commentaires, j'ai prolongé le test pour couvrir tous les quatre combinaisons de toMap, groupingBy, en série et en parallèle.

    Les résultats ne sont que le toMap approche est plus rapide, mais de façon inattendue (au moins, pour moi) le "concurrent" des versions dans les deux cas sont plus lentes que les versions série...:

                 (method)  (count) (wordLength)  Mode  Cnt     Score    Error  Units
toConcurrentMap     1000            2  avgt   50   146,636 ±  0,880  us/op
toConcurrentMap     1000            5  avgt   50   272,762 ±  1,232  us/op
toConcurrentMap     1000           10  avgt   50   271,121 ±  1,125  us/op
toMap     1000            2  avgt   50    44,396 ±  0,541  us/op
toMap     1000            5  avgt   50    46,938 ±  0,872  us/op
toMap     1000           10  avgt   50    46,180 ±  0,557  us/op
groupingBy     1000            2  avgt   50    46,797 ±  1,181  us/op
groupingBy     1000            5  avgt   50    68,992 ±  1,537  us/op
groupingBy     1000           10  avgt   50    68,636 ±  1,349  us/op
groupingByConcurrent     1000            2  avgt   50   231,458 ±  0,658  us/op
groupingByConcurrent     1000            5  avgt   50   438,975 ±  1,591  us/op
groupingByConcurrent     1000           10  avgt   50   437,765 ±  1,139  us/op
toConcurrentMap    10000            2  avgt   50   712,113 ±  6,340  us/op
toConcurrentMap    10000            5  avgt   50  1809,356 ±  9,344  us/op
toConcurrentMap    10000           10  avgt   50  1813,814 ± 16,190  us/op
toMap    10000            2  avgt   50   341,004 ± 16,074  us/op
toMap    10000            5  avgt   50   535,122 ± 24,674  us/op
toMap    10000           10  avgt   50   511,186 ±  3,444  us/op
groupingBy    10000            2  avgt   50   340,984 ±  6,235  us/op
groupingBy    10000            5  avgt   50   708,553 ±  6,369  us/op
groupingBy    10000           10  avgt   50   712,858 ± 10,248  us/op
groupingByConcurrent    10000            2  avgt   50   901,842 ±  8,685  us/op
groupingByConcurrent    10000            5  avgt   50  3762,478 ± 21,408  us/op
groupingByConcurrent    10000           10  avgt   50  3795,530 ± 32,096  us/op

    Je ne suis pas tellement d'expérience avec JMH, peut-être que j'ai fait quelque chose de mal ici - suggestions et corrections sont les bienvenues:

    import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;
@State(Scope.Thread)
public class ParallelWordCount
{
@Param({"toConcurrentMap", "toMap", "groupingBy", "groupingByConcurrent"})
public String method;
@Param({"2", "5", "10"})
public int wordLength;
@Param({"1000", "10000" })
public int count;
private List<String> list;
@Setup
public void initList()
{
list = createRandomStrings(count, wordLength, new Random(0));
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testMethod(Blackhole bh)
{
if (method.equals("toMap"))
{
Map<String, Integer> counts =
list.stream().collect(
Collectors.toMap(
w -> w, w -> 1, Integer::sum));
bh.consume(counts);
}
else if (method.equals("toConcurrentMap"))
{
Map<String, Integer> counts =
list.parallelStream().collect(
Collectors.toConcurrentMap(
w -> w, w -> 1, Integer::sum));
bh.consume(counts);
}
else if (method.equals("groupingBy"))
{
Map<String, Long> counts =
list.stream().collect(
Collectors.groupingBy(
Function.identity(), Collectors.<String>counting()));
bh.consume(counts);
}
else if (method.equals("groupingByConcurrent"))
{
Map<String, Long> counts =
list.parallelStream().collect(
Collectors.groupingByConcurrent(
Function.identity(), Collectors.<String> counting()));
bh.consume(counts);
}
}
private static String createRandomString(int length, Random random)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++)
{
int c = random.nextInt(26);
sb.append((char) (c + 'a'));
}
return sb.toString();
}
private static List<String> createRandomStrings(
int count, int length, Random random)
{
List<String> list = new ArrayList<String>(count);
for (int i = 0; i < count; i++)
{
list.add(createRandomString(length, random));
}
return list;
}
}

    Les temps ne sont similaires pour la série de cas d'une liste de 10000 éléments, et 2-lettre des mots.

    Il pourrait être intéressant de vérifier si, même pour la plus grande liste des tailles, le concurrent versions éventuellement surpasser la série, mais n'ont pas le temps pour une autre référence avec toutes ces configurations.

    • Je suppose que, Collectors.groupingByConcurrent(w->w, Collectors.counting()) sera plus efficace.
    • J'ai ajouté une modification à ce sujet.
    • Vous devriez aussi savoir le nombre de égal mots. La contention pour une carte unique entrée peut avoir un impact significatif. Le comptage des milliers de mots distincts pourrait fonctionner sans la discorde dans Java 8 ConcurrentMap bien que je ne dirais pas stocker 1s “comptage”. Donc, en comptant mille occurrences d'un même mot peut donner une autre image...
    • Bien sûr, c'est ce que j'ai essayé de couvrir (dans la mesure du possible) avec une taille de la liste de 10000 contenant aléatoire de mots de longueur 2: Il y a entre 6 et 32 (moyenne: ~15) occurrances des mêmes mots. Un rapide (!) test avec 100000 fois "aa" il semble que les temps sont de plus en plus semblables alors, mais ce test ne prend pas en dire beaucoup au sujet de la performance dans un réaliste cas d'application.
    • Ce serait formidable si vous pouviez poster votre code de référence.
    • Je ne voulais pas d'enfler la réponse à quelque chose qui n'a pas vraiment répondre à la question, mais je vais nettoyer et poste le code plus tard aujourd'hui.
    • Compréhensible, mais au moment de discuter de solutions de rechange, une comparaison sera utile. Après tout, même les OP propre groupingBy approche peut fonctionner en parallèle et il serait bon d'élargir le point de référence de voir les différences entre toutes les variantes (groupingBy vs toMap)×(ordinaire vs Concurrent)...

    InformationsquelleAutor Marco13
  3. 6

    Trouver plus fréquentes de l'élément dans la collection, avec les génériques:

    private <V> V findMostFrequentItem(final Collection<V> items)
{
return items.stream()
.filter(Objects::nonNull)
.collect(Collectors.groupingBy(Functions.identity(), Collectors.counting()))
.entrySet()
.stream()
.max(Comparator.comparing(Entry::getValue))
.map(Entry::getKey)
.orElse(null);
}

    De calcul de l'élément de fréquences:

    private <V> Map<V, Long> findFrequencies(final Collection<V> items)
{
return items.stream()
.filter(Objects::nonNull)
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
}
    InformationsquelleAutor nejckorasa
  4. 3

    Si vous utilisez Eclipse Collections, il vous suffit de convertir le List à un Sac.

    Bag<String> words = Lists.mutable.with("hello", "bye", "ciao", "bye", "ciao").toBag();
Assert.assertEquals(2, words.occurrencesOf("ciao"));
Assert.assertEquals(1, words.occurrencesOf("hello"));
Assert.assertEquals(2, words.occurrencesOf("bye"));

    Ce code fonctionne avec Java 5 - 8.

    Remarque: je suis un committer pour Eclipse Collections

    InformationsquelleAutor Donald Raab
  5. 3

    Voici une façon de créer une fréquence de la carte en utilisant les fonctions de mappage.

    List<String> words = Stream.of("hello", "bye", "ciao", "bye", "ciao").collect(toList());
Map<String, Integer> frequencyMap = new HashMap<>();
words.forEach(word ->
frequencyMap.merge(word, 1, (v, newV) -> v + newV)
);
System.out.println(frequencyMap); //{ciao=2, hello=1, bye=2}

    Ou

    words.forEach(word ->
frequencyMap.compute(word, (k, v) -> v != null ? v + 1 : 1)
);
    • J'aime la carte.de fusion, mais pas sûr de savoir pourquoi vous avez fait tout ce travail pour créer une Liste<String> les mots, pourquoi ne pas simplement faire : List<String> liste = Arrays.asList("bonjour", "au revoir", "ciao", "au revoir", "ciao")
    • Merci! À propos de la création d'une liste de code, je reste loin de Tableaux.asList parce qu'elle renvoie un java.util.Tableaux$ArrayList au lieu de l'habituelle liste de tableaux. Je préfère ne pas l'utiliser parce que finalement, si les données vont être activé dans votre application, il crée indésirables sérialisé structure avec des Tableaux.asList.
    InformationsquelleAutor Piyush
  6. 2

    Je vais vous présenter ici la solution que j'ai faite (celle avec le groupement est beaucoup mieux 🙂 ).

    static private void test0(List<String> input) {
Set<String> set = input.stream()
.collect(Collectors.toSet());
set.stream()
.collect(Collectors.toMap(Function.identity(),
str -> Collections.frequency(input, str)));
}

    Juste mon 0.02$

    InformationsquelleAutor Eugene
  7. 0

    Un autre 2% de la mine, étant donné un tableau:

    import static java.util.stream.Collectors.*;
String[] str = {"hello", "bye", "ciao", "bye", "ciao"};    
Map<String, Integer> collected 
= Arrays.stream(str)
.collect(groupingBy(Function.identity(), 
collectingAndThen(counting(), Long::intValue)));
    InformationsquelleAutor Sym-Sym
  8. 0
    public class Main {
public static void main(String[] args) {
String testString ="qqwweerrttyyaaaaaasdfasafsdfadsfadsewfywqtedywqtdfewyfdweytfdywfdyrewfdyewrefdyewdyfwhxvsahxvfwytfx"; 
long java8Case2 = testString.codePoints().filter(ch -> ch =='a').count();
System.out.println(java8Case2);
ArrayList<Character> list = new ArrayList<Character>();
for (char c : testString.toCharArray()) {
list.add(c);
}
Map<Object, Integer> counts = list.parallelStream().
collect(Collectors.toConcurrentMap(
w -> w, w -> 1, Integer::sum));
System.out.println(counts);
}
}
    InformationsquelleAutor Easycoder