Zippare i flussi utilizzando JDK8 con lambda (java.util.stream.Streams.zip)

Question

In JDK 8 con lambda b93 c'era una classe java.util.stream.Streams.zip in b93 che poteva essere utilizzata per i flussi zip (questo è illustrato nel tutorial Exploring Java8 Lambdas. Part 1 by Dhananjay Nene). Questa funzione:

crea un flusso artificiale e combinata sequenziale i cui elementi sono il risultato di combinando gli elementi di due flussi.

Tuttavia in b98 questo è scomparso. Infatti la classe Streams non è nemmeno accessibile in java.util.stream in b98.

Questa funzionalità è stata spostata e, in caso affermativo, come faccio a comprimere i flussi in modo conciso utilizzando b98?

L'applicazione che ho in mente è in this java implementation of Shen, dove ho sostituito la funzionalità zip nella

• static <T> boolean every(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred)
• static <T> T find(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred)

funzioni con codice piuttosto dettagliato (che non utilizza funzionalità da b98).

Answer 1

avevo bisogno di questo pure così ho preso il codice sorgente da B93 e metterlo in una classe "util". Ho dovuto modificarlo leggermente per lavorare con l'API corrente.

Per riferimento qui è il codice di lavoro (prendere a vostro rischio ...):

public static<A, B, C> Stream<C> zip(Stream<? extends A> a, 
            Stream<? extends B> b, 
            BiFunction<? super A, ? super B, ? extends C> zipper) { 
    Objects.requireNonNull(zipper); 
    Spliterator<? extends A> aSpliterator = Objects.requireNonNull(a).spliterator(); 
    Spliterator<? extends B> bSpliterator = Objects.requireNonNull(b).spliterator(); 

    // Zipping looses DISTINCT and SORTED characteristics 
    int characteristics = aSpliterator.characteristics() & bSpliterator.characteristics() & 
      ~(Spliterator.DISTINCT | Spliterator.SORTED); 

    long zipSize = ((characteristics & Spliterator.SIZED) != 0) 
      ? Math.min(aSpliterator.getExactSizeIfKnown(), bSpliterator.getExactSizeIfKnown()) 
      : -1; 

    Iterator<A> aIterator = Spliterators.iterator(aSpliterator); 
    Iterator<B> bIterator = Spliterators.iterator(bSpliterator); 
    Iterator<C> cIterator = new Iterator<C>() { 
     @Override 
     public boolean hasNext() { 
      return aIterator.hasNext() && bIterator.hasNext(); 
     } 

     @Override 
     public C next() { 
      return zipper.apply(aIterator.next(), bIterator.next()); 
     } 
    }; 

    Spliterator<C> split = Spliterators.spliterator(cIterator, zipSize, characteristics); 
    return (a.isParallel() || b.isParallel()) 
      ? StreamSupport.stream(split, true) 
      : StreamSupport.stream(split, false); 
} 

Answer 2

La libreria Lazy-Seq fornisce funzionalità zip.

https://github.com/nurkiewicz/LazySeq

Questa libreria è fortemente ispirato scala.collection.immutable.Stream e mira a fornire, implementazione sequenza immutabile thread-safe e facile da usare pigri, forse infinita.

Answer 3

I metodi della classe menzionata sono stati spostati nell'interfaccia Stream in favore dei metodi predefiniti. Ma sembra che il metodo zip sia stato rimosso. Forse perché non è chiaro quale dovrebbe essere il comportamento predefinito per i flussi di dimensioni diverse. Ma l'attuazione del comportamento desiderato è straight-forward:

static <T> boolean every(
    Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred) { 
    Iterator<T> it=c2.iterator(); 
    return c1.stream().allMatch(x->!it.hasNext()||pred.test(x, it.next())); 
} 
static <T> T find(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred) { 
    Iterator<T> it=c2.iterator(); 
    return c1.stream().filter(x->it.hasNext()&&pred.test(x, it.next())) 
     .findFirst().orElse(null); 
} 

Answer 4

zip è una delle funzioni fornite dal protonpack library.

Stream<String> streamA = Stream.of("A", "B", "C"); 
Stream<String> streamB = Stream.of("Apple", "Banana", "Carrot", "Doughnut"); 

List<String> zipped = StreamUtils.zip(streamA, 
             streamB, 
             (a, b) -> a + " is for " + b) 
           .collect(Collectors.toList()); 

assertThat(zipped, 
      contains("A is for Apple", "B is for Banana", "C is for Carrot")); 

Answer 5

public class Tuple<S,T> { 
    private final S object1; 
    private final T object2; 

    public Tuple(S object1, T object2) { 
     this.object1 = object1; 
     this.object2 = object2; 
    } 

    public S getObject1() { 
     return object1; 
    } 

    public T getObject2() { 
     return object2; 
    } 
} 


public class StreamUtils { 

    private StreamUtils() { 
    } 

    public static <T> Stream<Tuple<Integer,T>> zipWithIndex(Stream<T> stream) { 
     Stream<Integer> integerStream = IntStream.range(0, Integer.MAX_VALUE).boxed(); 
     Iterator<Integer> integerIterator = integerStream.iterator(); 
     return stream.map(x -> new Tuple<>(integerIterator.next(), x)); 
    } 
} 

Answer 6

Zipping due flussi usando JDK8 con lambda (gist).

public static <A, B, C> Stream<C> zip(Stream<A> streamA, Stream<B> streamB, BiFunction<A, B, C> zipper) { 
    final Iterator<A> iteratorA = streamA.iterator(); 
    final Iterator<B> iteratorB = streamB.iterator(); 
    final Iterator<C> iteratorC = new Iterator<C>() { 
     @Override 
     public boolean hasNext() { 
      return iteratorA.hasNext() && iteratorB.hasNext(); 
     } 

     @Override 
     public C next() { 
      return zipper.apply(iteratorA.next(), iteratorB.next()); 
     } 
    }; 
    final boolean parallel = streamA.isParallel() || streamB.isParallel(); 
    return iteratorToFiniteStream(iteratorC, parallel); 
} 

public static <T> Stream<T> iteratorToFiniteStream(Iterator<T> iterator, boolean parallel) { 
    final Iterable<T> iterable =() -> iterator; 
    return StreamSupport.stream(iterable.spliterator(), parallel); 
} 

Answer 7

AOL cyclops-react, a cui contribuisco, fornisce anche zippare funzionalità, sia tramite un extended Stream implementation, che implementa anche l'reattivi-stream interfaccia ReactiveSeq, e via StreamUtils che offre molte delle stesse funzionalità attraverso metodi statici a norma Stream Java.

List<Tuple2<Integer,Integer>> list = ReactiveSeq.of(1,2,3,4,5,6) 
                .zip(Stream.of(100,200,300,400)); 


    List<Tuple2<Integer,Integer>> list = StreamUtils.zip(Stream.of(1,2,3,4,5,6), 
                Stream.of(100,200,300,400)); 

offre anche più generalizzata zippare base applicativo. Per esempio.

ReactiveSeq.of("a","b","c") 
       .ap3(this::concat) 
       .ap(of("1","2","3")) 
       .ap(of(".","?","!")) 
       .toList(); 

    //List("a1.","b2?","c3!"); 

    private String concat(String a, String b, String c){ 
    return a+b+c; 
    } 

E anche la possibilità di abbinare ogni elemento in un unico flusso con ogni elemento in un altro

ReactiveSeq.of("a","b","c") 
       .forEach2(str->Stream.of(str+"!","2"), a->b->a+"_"+b); 

    //ReactiveSeq("a_a!","a_2","b_b!","b_2","c_c!","c2") 

Answer 8

Questo è grande. Ho dovuto zip due flussi in una mappa con un flusso di essere la chiave e altro è il valore

Stream<String> streamA = Stream.of("A", "B", "C"); 
Stream<String> streamB = Stream.of("Apple", "Banana", "Carrot", "Doughnut");  
final Stream<Map.Entry<String, String>> s = StreamUtils.zip(streamA, 
        streamB, 
        (a, b) -> { 
         final Map.Entry<String, String> entry = new AbstractMap.SimpleEntry<String, String>(a, b); 
         return entry; 
        }); 

System.out.println(s.collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()))); 

uscita: {A = Apple, B = Banana, C = Carota}

Answer 9

Dal momento che posso 't concepire qualsiasi utilizzo di zippare su collezioni diverse da quelle indicizzate (liste) e io sono un grande fan di semplicità, questa sarebbe la mia soluzione:

<A,B,C> Stream<C> zipped(List<A> lista, List<B> listb, BiFunction<A,B,C> zipper){ 
    int shortestLength = Math.min(lista.size(),listb.size()); 
    return IntStream.range(0,shortestLength).mapToObject(i -> { 
      return zipper.apply(lista.get(i), listb.get(i)); 
    });   
} 

Answer 10

Se si dispone di Guava nel progetto, è possibile utilizzare il Metodo Streams.zip (è stato aggiunto in Guava 21):

Restituisce un flusso in cui ogni elemento è il risultato del passaggio dell'elemento corrispondente di ciascuno di streamA e streamB per funzionare. Il flusso risultante sarà lungo solo quanto il più breve dei due flussi di input; se uno stream è più lungo, i suoi elementi extra verranno ignorati. Il flusso risultante non è divisibile in modo efficiente. Ciò potrebbe danneggiare le prestazioni parallele.

public class Streams { 
    ... 

    public static <A, B, R> Stream<R> zip(Stream<A> streamA, 
      Stream<B> streamB, BiFunction<? super A, ? super B, R> function) { 
     ... 
    } 
} 

Answer 11

umilmente suggerisco questa implementazione. Il flusso risultante viene troncato al più breve dei due flussi di input.

public static <L, R, T> Stream<T> zip(Stream<L> leftStream, Stream<R> rightStream, BiFunction<L, R, T> combiner) { 
    Spliterator<L> lefts = leftStream.spliterator(); 
    Spliterator<R> rights = rightStream.spliterator(); 
    return StreamSupport.stream(new AbstractSpliterator<T>(Long.min(lefts.estimateSize(), rights.estimateSize()), lefts.characteristics() & rights.characteristics()) { 
     @Override 
     public boolean tryAdvance(Consumer<? super T> action) { 
      return lefts.tryAdvance(left->rights.tryAdvance(right->action.accept(combiner.apply(left, right)))); 
     } 
    }, leftStream.isParallel() || rightStream.isParallel()); 
}