Puoi dividere un flusso in due flussi?

Ho un set di dati rappresentato da un flusso Java 8:

Stream<T> stream = ...;

Vedo come filtrarlo per ottenere un sottoinsieme casuale, ad esempio

Random r = new Random();
PrimitiveIterator.OfInt coin = r.ints(0, 2).iterator();   
Stream<T> heads = stream.filter((x) -> (coin.nextInt() == 0));

Posso anche vedere come potrei ridurre questo flusso per ottenere, ad esempio, due elenchi che rappresentano due metà casuali del set di dati e quindi trasformarli nuovamente in flussi. Ma esiste un modo diretto per generare due flussi da quello iniziale? Qualcosa di simile a

(heads, tails) = stream.[some kind of split based on filter]

Grazie per qualsiasi approfondimento.

Non esattamente. Non puoi ottenere due Streams da uno; questo non ha senso: come faresti a scorrere su uno senza dover generare l'altro allo stesso tempo? Un flusso può essere gestito solo una volta.

Tuttavia, se vuoi scaricarli in un elenco o qualcosa del genere, puoi farlo

stream.forEach((x) -> ((x == 0) ? heads : tails).add(x));

Un collezionista può essere utilizzato per questo.

• Per due categorie, utilizzare Collectors.partitioningBy()factory.

Ciò creerà un Mapda Booleana Liste inserirà gli elementi in uno o l'altro elenco in base a a Predicate.

Nota: poiché il flusso deve essere consumato intero, questo non può funzionare su flussi infiniti. E poiché lo stream viene comunque consumato, questo metodo li inserisce semplicemente negli elenchi invece di creare un nuovo stream con memoria. È sempre possibile eseguire lo streaming di tali elenchi se si richiedono flussi come output.

Inoltre, non è necessario l'iteratore, nemmeno nell'esempio solo testa che hai fornito.

• La divisione binaria si presenta così:

Random r = new Random();

Map<Boolean, List<String>> groups = stream
    .collect(Collectors.partitioningBy(x -> r.nextBoolean()));

System.out.println(groups.get(false).size());
System.out.println(groups.get(true).size());

• Per più categorie, utilizzare una Collectors.groupingBy()fabbrica.

Map<Object, List<String>> groups = stream
    .collect(Collectors.groupingBy(x -> r.nextInt(3)));
System.out.println(groups.get(0).size());
System.out.println(groups.get(1).size());
System.out.println(groups.get(2).size());

Nel caso in cui i flussi non lo siano Stream, ma piace uno dei flussi primitivi IntStream, questo .collect(Collectors)metodo non è disponibile. Dovrai farlo manualmente senza una fabbrica di collezionisti. La sua implementazione è simile alla seguente:

[Esempio 2.0 dal 2020-04-16]

    IntStream    intStream = IntStream.iterate(0, i -> i + 1).limit(100000).parallel();
    IntPredicate predicate = ignored -> r.nextBoolean();

    Map<Boolean, List<Integer>> groups = intStream.collect(
            () -> Map.of(false, new ArrayList<>(100000),
                         true , new ArrayList<>(100000)),
            (map, value) -> map.get(predicate.test(value)).add(value),
            (map1, map2) -> {
                map1.get(false).addAll(map2.get(false));
                map1.get(true ).addAll(map2.get(true ));
            });

In questo esempio, inizializzo gli ArrayLists con l'intera dimensione della raccolta iniziale (se questo è noto). Questo impedisce gli eventi di ridimensionamento anche nello scenario peggiore, ma può potenzialmente inghiottire 2 * N * T spazio (N = numero iniziale di elementi, T = numero di thread). Per compensare lo spazio per la velocità, puoi lasciarlo fuori o usare la tua ipotesi più istruita, come il numero più alto previsto di elementi in una partizione (in genere appena sopra N / 2 per una divisione bilanciata).

Spero di non offendere nessuno usando un metodo Java 9. Per la versione Java 8, guarda la cronologia delle modifiche.

Mi sono imbattuto in questa domanda per me stesso e sento che un flusso biforcuto ha alcuni casi d'uso che potrebbero dimostrarsi validi. Ho scritto il codice qui sotto come consumatore in modo che non faccia nulla ma tu possa applicarlo a funzioni e qualsiasi altra cosa che potresti incontrare.

class PredicateSplitterConsumer<T> implements Consumer<T>
{
  private Predicate<T> predicate;
  private Consumer<T>  positiveConsumer;
  private Consumer<T>  negativeConsumer;

  public PredicateSplitterConsumer(Predicate<T> predicate, Consumer<T> positive, Consumer<T> negative)
  {
    this.predicate = predicate;
    this.positiveConsumer = positive;
    this.negativeConsumer = negative;
  }

  @Override
  public void accept(T t)
  {
    if (predicate.test(t))
    {
      positiveConsumer.accept(t);
    }
    else
    {
      negativeConsumer.accept(t);
    }
  }
}

Ora l'implementazione del codice potrebbe essere simile a questa:

personsArray.forEach(
        new PredicateSplitterConsumer<>(
            person -> person.getDateOfBirth().isPresent(),
            person -> System.out.println(person.getName()),
            person -> System.out.println(person.getName() + " does not have Date of birth")));

Sfortunatamente, ciò che chiedi è direttamente disapprovato nel JavaDoc di Stream :

Un flusso deve essere gestito (invocando un'operazione di flusso intermedio o terminale) una sola volta. Questo esclude, ad esempio, flussi "biforcati", in cui la stessa sorgente alimenta due o più condotte o più attraversamenti dello stesso flusso.

Puoi aggirare questo usando peeko altri metodi se desideri veramente quel tipo di comportamento. In questo caso, ciò che dovresti fare è invece di provare a eseguire il backup di due stream dalla stessa sorgente Stream originale con un filtro di fork, duplicando il flusso e filtrando ciascuno dei duplicati in modo appropriato.

Tuttavia, potresti voler riconsiderare se a Streamè la struttura appropriata per il tuo caso d'uso.

Questo è contro il meccanismo generale di Stream. Supponi di poter dividere Stream S0 in Sa e Sb come desideri. Eseguire qualsiasi operazione terminale, diciamo count(), su Sa necessariamente "consumerà" tutti gli elementi in S0. Pertanto Sb ha perso la sua fonte di dati.

In precedenza, Stream aveva un tee()metodo, credo, che duplicava uno stream in due. È stato rimosso ora.

Stream ha un metodo peek (), tuttavia potresti essere in grado di usarlo per raggiungere i tuoi requisiti.

non esattamente, ma potresti essere in grado di realizzare ciò di cui hai bisogno invocando Collectors.groupingBy(). crei una nuova raccolta e puoi quindi istanziare i flussi su quella nuova raccolta.

Questa è stata la risposta meno negativa che ho potuto trovare.

import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;

public class Test {

    public static <T, L, R> Pair<L, R> splitStream(Stream<T> inputStream, Predicate<T> predicate,
            Function<Stream<T>, L> trueStreamProcessor, Function<Stream<T>, R> falseStreamProcessor) {

        Map<Boolean, List<T>> partitioned = inputStream.collect(Collectors.partitioningBy(predicate));
        L trueResult = trueStreamProcessor.apply(partitioned.get(Boolean.TRUE).stream());
        R falseResult = falseStreamProcessor.apply(partitioned.get(Boolean.FALSE).stream());

        return new ImmutablePair<L, R>(trueResult, falseResult);
    }

    public static void main(String[] args) {

        Stream<Integer> stream = Stream.iterate(0, n -> n + 1).limit(10);

        Pair<List<Integer>, String> results = splitStream(stream,
                n -> n > 5,
                s -> s.filter(n -> n % 2 == 0).collect(Collectors.toList()),
                s -> s.map(n -> n.toString()).collect(Collectors.joining("|")));

        System.out.println(results);
    }

}

Questo prende un flusso di numeri interi e li divide in 5. Per quelli maggiori di 5 filtra solo i numeri pari e li mette in un elenco. Per il resto li unisce a |.

uscite:

 ([6, 8],0|1|2|3|4|5)

Non è l'ideale in quanto raccoglie tutto in raccolte intermedie che interrompono il flusso (e ha troppi argomenti!)

Mi sono imbattuto in questa domanda mentre cercavo un modo per filtrare determinati elementi da un flusso e registrarli come errori. Quindi non avevo davvero bisogno di dividere lo stream tanto quanto collegare un'azione di terminazione prematura a un predicato con sintassi discreta. Questo è quello che mi è venuto in mente:

public class MyProcess {
    /* Return a Predicate that performs a bail-out action on non-matching items. */
    private static <T> Predicate<T> withAltAction(Predicate<T> pred, Consumer<T> altAction) {
    return x -> {
        if (pred.test(x)) {
            return true;
        }
        altAction.accept(x);
        return false;
    };

    /* Example usage in non-trivial pipeline */
    public void processItems(Stream<Item> stream) {
        stream.filter(Objects::nonNull)
              .peek(this::logItem)
              .map(Item::getSubItems)
              .filter(withAltAction(SubItem::isValid,
                                    i -> logError(i, "Invalid")))
              .peek(this::logSubItem)
              .filter(withAltAction(i -> i.size() > 10,
                                    i -> logError(i, "Too large")))
              .map(SubItem::toDisplayItem)
              .forEach(this::display);
    }
}

Versione più breve che utilizza Lombok

import java.util.function.Consumer;
import java.util.function.Predicate;

import lombok.RequiredArgsConstructor;

/**
 * Forks a Stream using a Predicate into postive and negative outcomes.
 */
@RequiredArgsConstructor
@FieldDefaults(makeFinal = true, level = AccessLevel.PROTECTED)
public class StreamForkerUtil<T> implements Consumer<T> {
    Predicate<T> predicate;
    Consumer<T> positiveConsumer;
    Consumer<T> negativeConsumer;

    @Override
    public void accept(T t) {
        (predicate.test(t) ? positiveConsumer : negativeConsumer).accept(t);
    }
}

Che ne dite di:

Supplier<Stream<Integer>> randomIntsStreamSupplier =
    () -> (new Random()).ints(0, 2).boxed();

Stream<Integer> tails =
    randomIntsStreamSupplier.get().filter(x->x.equals(0));
Stream<Integer> heads =
    randomIntsStreamSupplier.get().filter(x->x.equals(1));