Java 8에는 스트림의 varags에서 작동하는 Stream.concat이 부족합니까?

Question

현재 우리는 자바 8 Stream.concat을 다음 있습니다 :

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

내가 Stream<? extends T>의 가변 인자를 가지고 어떤 버전이없는 이유에 놀란다? 이 서명의 가변 인자를 사용할 수 있다면

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

:

은 현재 내가 코드처럼 작성했습니다

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); 

가 그럼 난으로 훨씬 더 명확하게 쓸 수

모든 종류의 중첩 된 Stream.concat 호출없이.

또는 제공되지 않는 다른 이유가 있습니까?
나는 그런 이유로 생각할 수 없다. 어쨌든 지금은 varargs 호출 작업을 끝내기 때문이다.

Answer 1

그냥 flatMap 그것을 :

당신의 예에서

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()); 
} 

:

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

수집 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, 집계 답변 of.flatMap()of.reduce().orElseGet() 대 : of.flatMap 처리 할 수없는 무한한 시내 s 일 때 of.reduce() - 할 수 있습니다. 아래의 시험 예를 참조하십시오

@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)); 
} 
}