Ist es möglich Elemente von Java8 Streams zu "fusionieren"?

Question

Kann ich vorherige und/oder nächste Elemente analysiere mit Java8 irgendwie Ströme?

Zum Beispiel kann ich zählen identisch benachbarte Zahlen?

public class Merge { 
    public static void main(String[] args) { 

     Stream<Integer> stream = Stream.of(0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1); 

     // How to get 3, 2, 2, 4 from above 

    } 
} 

Answer 1

Wenn Sie es faul sein wollen, müssen Sie den Stream-API durch Stream.iterator() oder Stream.spliterator() entkommen.

Ansonsten ist der Weg, es zu tun ist, um den Terminalbetrieb Stream.collect(Collector) mit einem benutzerdefinierten Kollektor zu nennen, die den ganzen Strom verbrauchen.

---

@Test 
public void test() { 
    Stream<Integer> input = Stream.of(0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1); 

    UniqCountSpliterator uniqCountSpliterator = new UniqCountSpliterator(input.spliterator()); 

    long[] output = uniqCountSpliterator.stream() 
      .toArray(); 

    long[] expected = {3, 2, 2, 4}; 

    assertArrayEquals(expected, output); 
} 

---

import java.util.Spliterator; 
import java.util.function.LongConsumer; 
import java.util.stream.Stream; 
import java.util.stream.StreamSupport; 

public class UniqCountSpliterator implements Spliterator.OfLong { 
    private Spliterator wrapped; 
    private long count; 
    private Object previous; 
    private Object current; 

    public UniqCountSpliterator(Spliterator wrapped) { 
     this.wrapped = wrapped; 
    } 

    public LongStream stream() { 
     return StreamSupport.longStream(this, false); 
    } 

    @Override 
    public OfLong trySplit() { 
     return null; 
    } 

    @Override 
    public long estimateSize() { 
     return Long.MAX_VALUE; 
    } 

    @Override 
    public int characteristics() { 
     return NONNULL | IMMUTABLE; 
    } 

    @Override 
    public boolean tryAdvance(LongConsumer action) { 
     while (wrapped.tryAdvance(next -> current = next) && (null == previous || current.equals(previous))) { 
      count++; 
      previous = current; 
     } 
     if (previous == null) { 
      return false; 
     } 
     action.accept(count); 
     count = 1; 
     previous = null; 
     return true; 
    } 
} 

Answer 2

Sie können fast tun es mit flatMap. Es würde für unendliche Ströme funktionieren, mit endlichem Strom sehe ich keine Möglichkeit, das Ende des Stromes in ihm zu erkennen.

Stream<Integer> stream = Stream.of(0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1); 

    Stream<Integer> flatMap = stream.flatMap(new Function<Integer, Stream<Integer>>() { 
     Integer prev = null; 
     int count; 
     public java.util.stream.Stream<Integer> apply(Integer i) { 
      if (i.equals(prev)) { 
       count++; 
       return Stream.empty(); 
      } else { 
       int c = count; 
       count = 1; 
       prev = i; 
       if (c > 0) { 
        return Stream.of(c); 
       } else { 
        return Stream.empty(); 
       } 
      } 
     }; 
    }); 

    flatMap.forEach(i -> { 
     System.out.println(i); 
    }); 

sagte, dass Sie wahrscheinlich viel bessere Kilometerleistung aus rxjava für eine solche Art von Dingen bekommen könnte (wo man Subject nutzen könnten Werte emittieren, wie Sie wollen und in der Lage sein Ende Stream zu erkennen).

Natürlich, wenn Sie Stream-Grenzen entkommen wollen, gibt es viele Möglichkeiten, wie Christ Antwort angegeben.

Answer 3

Wenn Sie nicht zwei Aussagen dagegen haben, können Sie Setup eine Liste mit den Zählungen zu füllen, und dann verwenden reduce:

List<Integer> counts = new ArrayList<>(); 
Stream.of(0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1).reduce((i, j) -> { 
    if (counts.isEmpty()) { 
     counts.add(1); 
    } 

    if (j == i) { 
     int index = counts.size() - 1; 
     counts.set(index, counts.get(index) + 1); 
    } else { 
     counts.add(1); 
    } 
    return j; 
});