Fehlt Java 8 ein Stream.concat, das an einem Varar von Streams arbeitet?

Question

Zur Zeit haben wir folgende Stream.concat in Java 8:

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b); 

Ich bin überrascht, warum gibt es keine Version eine varargs von Stream<? extends T> zu nehmen?

Zur Zeit habe ich Code geschrieben wie:

Stream<Integer> resultStream = Stream.concat(stream1, Stream.concat(stream2, Stream.of(element))) 
     .filter(x -> x != 0) 
     .filter(x -> x != 1) 
     .filter(x -> x != 2); 

Wenn ein varargs dieser Signatur verfügbar waren:

Stream<Integer> resultStream = Stream.concat(
       stream1, 
       stream2, 
       Stream.of(element) 
     ) 
     .filter(x -> x != 0) 
     .filter(x -> x != 1) 
     .filter(x -> x != 2); 

:

public static <T> Stream<T> concat(Stream<? extends T>... streams); 

Dann habe ich es viel deutlicher als schreiben konnte

Ohne alle verschachtelten Stream.concat Anrufe.

Oder gibt es andere Gründe, warum es nicht zur Verfügung gestellt wird?
Ich kann mir solche Gründe nicht vorstellen, da wir jetzt sowieso den Job eines Varargs Calls machen.

Answer 1

Gerade flatMap es:

public static void main(final String[] args) throws Exception { 
    final Stream<String> stream1 = /*some stream*/ 
    final Stream<String> stream2 = /*some stream*/ 
    final Stream<String> stream3 = /*some stream*/ 
    final Stream<String> stream4 = /*some stream*/ 
    final Stream<String> stream5 = /*some stream*/ 

    final Stream<String> stream = Stream.of(stream1, stream2, stream3, stream4, stream5).flatMap(Function.identity()); 
} 

In Ihrem Beispiel:

Stream<Integer> resultStream = Stream.of(stream1, stream2, Stream.of(element)) 
     .flatMap(identity()) 
     .filter(x -> x != 0) 
     .filter(x -> x != 1) 
     .filter(x -> x != 2); 

Answer 2

aufgelesen von a message in the thread linked by @RohitJain:

Stream.of(s1, s2, s3, ...) 
    /* .parallel() if you want*/ 
    .reduce(Stream::concat) 
    .orElseGet(Stream::empty); 

Answer 3

SO, Aggregieren Antworten of.flatMap() vs of.reduce().orElseGet(): of.flatMap nicht verarbeiten kann unendlicher Strom s, wenn of.reduce() - kann. Sehen Sie den Test Beispiel unten:

@RunWith(JUnit4.class) 
public class StreamConcatTest { 

@Rule 
public Timeout globalTimeout = Timeout.seconds(3); 

private static final Random randomSupplier = new Random(System.currentTimeMillis()); 

private Stream<Stream<Integer>> mergedStream; 

@Before 
public void setUp() throws Exception { 
    Stream<Integer> infinite = Stream.concat(
      Stream.of(1, 2, 3, 4, 5), 
      Stream.generate(randomSupplier::nextInt) 
    ); 

    Stream<Integer> finite1 = Stream.of(100, 101, 102, 103); 
    Stream<Integer> finite2 = Stream.of(222, 333, 444, 555); 

    mergedStream = Stream.of(infinite, finite1, finite2); 
} 

@Test 
public void of_flatMap_FAILS_BY_TIMEOUT() throws Exception { 
    Stream<Integer> streamToTest = mergedStream 
      .flatMap(i -> i); 

    assertThat(streamToTest 
        .skip(3) 
        .findFirst() // this should break infinite stream, but can't 
        .orElse(-1), 
      is(4)); 
} 

@Test 
public void of_reduce_SUCCESS() throws Exception { 
    Stream<Integer> streamToTest = mergedStream 
      .reduce(Stream::concat) 
      .orElseGet(Stream::empty); 

    assertThat(streamToTest 
        .skip(3) 
        .findFirst() // this really breaks infinite stream 
        .orElse(-1), 
      is(4)); 
} 
}