flusso Raccogliere con le operazioni di raggruppamento, di conteggio e filtraggio

Question

Sto cercando di raccogliere flusso di buttare via gli oggetti usati raramente come in questo esempio:

import java.util.*; 
import java.util.function.Function; 
import static java.util.stream.Collectors.*; 
import static org.hamcrest.MatcherAssert.assertThat; 
import static org.hamcrest.Matchers.containsInAnyOrder; 
import org.junit.Test; 

@Test 
public void shouldFilterCommonlyUsedWords() { 
    // given 
    List<String> allWords = Arrays.asList(
     "call", "feel", "call", "very", "call", "very", "feel", "very", "any"); 

    // when 
    Set<String> commonlyUsed = allWords.stream() 
      .collect(groupingBy(Function.identity(), counting())) 
      .entrySet().stream().filter(e -> e.getValue() > 2) 
      .map(Map.Entry::getKey).collect(toSet()); 

    // then 
    assertThat(commonlyUsed, containsInAnyOrder("call", "very")); 
} 

ho la sensazione che sia possibile farlo molto più semplice - ho ragione?

Answer 1

Qualche tempo fa ho wrote un distinct(atLeast) metodo sperimentale per la mia biblioteca:

public StreamEx<T> distinct(long atLeast) { 
    if (atLeast <= 1) 
     return distinct(); 
    AtomicLong nullCount = new AtomicLong(); 
    ConcurrentHashMap<T, Long> map = new ConcurrentHashMap<>(); 
    return filter(t -> { 
     if (t == null) { 
      return nullCount.incrementAndGet() == atLeast; 
     } 
     return map.merge(t, 1L, (u, v) -> (u + v)) == atLeast; 
    }); 
} 

Quindi l'idea era quella di utilizzare in questo modo:

Set<String> commonlyUsed = StreamEx.of(allWords).distinct(3).toSet(); 

Questo esegue una filtrazione stateful, che sembra un po 'brutta. Dubitavo che tale funzionalità fosse utile, quindi non l'ho unita al master branch. Ciononostante fa il lavoro in pass di single stream. Probabilmente dovrei farlo rivivere. Nel frattempo è possibile copiare questo codice nel metodo statico e usarlo in questo modo:

Set<String> commonlyUsed = distinct(allWords.stream(), 3).collect(Collectors.toSet()); 

Aggiornamento (2015/05/31): ho aggiunto il metodo distinct(atLeast) al StreamEx 0.3.1. È implementato utilizzando custom spliterator. I benchmark hanno mostrato che questa implementazione è significativamente più veloce per i flussi sequenziali rispetto al filtro stateful descritto sopra e in molti casi è anche più veloce di altre soluzioni proposte in questo argomento. Funziona anche se lo stream è null (il collector groupingBy non supporta null come classe, quindi le soluzioni basate su groupingBy falliranno se si incontra null).

Answer 2

Non c'è modo di creare un Map, a meno che non si desideri accettare una complessità della CPU molto elevata.

Tuttavia, è possibile rimuovere l'operazione secondocollect:

Map<String,Long> map = allWords.stream() 
    .collect(groupingBy(Function.identity(), HashMap::new, counting())); 
map.values().removeIf(l -> l<=2); 
Set<String> commonlyUsed=map.keySet(); 

Si noti che in Java 8, HashSet avvolge ancora un HashMap, in modo da utilizzare il keySet() di un HashMap, quando si desidera un Set nel il primo posto, non spreca spazio vista l'attuale implementazione.

Naturalmente, è possibile nascondere il post-processing in un Collector, se ci si sente più “streamy”:

Set<String> commonlyUsed = allWords.stream() 
    .collect(collectingAndThen(
     groupingBy(Function.identity(), HashMap::new, counting()), 
     map-> { map.values().removeIf(l -> l<=2); return map.keySet(); })); 

Answer 3

Io personalmente preferisco la soluzione di Holger (+1), ma, invece di rimuovere elementi dalla mappa groupingBy, vorrei filtro sua entrySet e mappa il risultato di un set nel finalizzatore (si sente ancora più streamy)

Set<String> commonlyUsed = allWords.stream().collect(
      collectingAndThen(
       groupingBy(identity(), counting()), 
       (map) -> map.entrySet().stream(). 
          filter(e -> e.getValue() > 2). 
          map(e -> e.getKey()). 
          collect(Collectors.toSet())));