流动Java中的concat（）-yiteyi-C++库

流动concat（）方法创建一个连接流，其中元素是第一个流的所有元素，然后是第二个流的所有元素。如果两个输入流都已排序，则结果流已排序，并且平行的如果任一输入流是并行的。

null

语法：

static <T> Stream<T> concat(Stream<? extends T> stream1, 
                            Stream<? extends T> stream2)

Where, T is the type of stream elements,
stream1 represents the first stream,
stream2 represents the second stream and
the function returns the concatenation of
the two input streams

呼叫流。concat（stream1，stream2）可以被认为是形成一个二叉树。所有输入流的串联在根上。单个输入流位于叶子上。下面给出了四个输入流a、b、c和d的树的一些示例。

对于两条流a和b，树看起来像：图片[1]-流动Java中的concat（）-yiteyi-C++库对于三条流a、b和c，树看起来像：图片[2]-流动Java中的concat（）-yiteyi-C++库对于四条流a、b、c和d，树的形状如下：图片[3]-流动Java中的concat（）-yiteyi-C++库每一个额外的输入流都会向树添加一层深度，并向所有其他流添加一层间接寻址。

注：流返回的元素。concat（）方法是有序的。例如，以下两行返回相同的结果：

Stream.concat(Stream.concat(stream1, stream2), stream3);
Stream.concat(stream1, Stream.concat(stream2, stream3));

但以下两种情况的结果是不同的。

Stream.concat(Stream.concat(stream1, stream2), stream3); 
Stream.concat(Stream.concat(stream2, stream1), stream3);

下面是一些例子，可以更好地理解函数的实现。 例1：

                     // Implementation of Stream.concat()                   
                     // method in Java 8 with 2 Streams                   
                     import                               java.util.*;                   
                     import                               java.util.stream.IntStream;                   
                     import                               java.util.stream.Stream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         // Creating two Streams                   
                                         Stream<String> stream1 = Stream.of(                               "Geeks"                               ,                               "for"                               );                   
                                         Stream<String> stream2 = Stream.of(                               "GeeksQuiz"                               ,                               "GeeksforGeeks"                               );                   
                             
                                         // concatenating both the Streams                   
                                         // with Stream.concat() function                   
                                         // and displaying the result                   
                                         Stream.concat(stream1, stream2)                   
                                         .forEach(element -> System.out.println(element));                   
                                         }                   
                     }                   

输出：

Geeks
for
GeeksQuiz
GeeksforGeeks

例2：

                     // Implementation of Stream.concat()                   
                     // method in Java 8 with more than                   
                     // two Streams                   
                     import                               java.util.*;                   
                     import                               java.util.stream.IntStream;                   
                     import                               java.util.stream.Stream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                             
                                         // Creating more than two Streams                   
                                         Stream<String> stream1 = Stream.of(                               "Geeks"                               );                   
                                         Stream<String> stream2 = Stream.of(                               "GeeksQuiz"                               );                   
                                         Stream<String> stream3 = Stream.of(                               "GeeksforGeeks"                               );                   
                                         Stream<String> stream4 = Stream.of(                               "GFG"                               );                   
                             
                                         // concatenating all the Streams                   
                                         // with Stream.concat() function                   
                                         // and displaying the result                   
                                         Stream.concat(Stream.concat(Stream.concat(stream1,                   
                                         stream2), stream3), stream4)                   
                                         .forEach(element -> System.out.println(element));                   
                                         }                   
                     }                   

输出：

Geeks
GeeksQuiz
GeeksforGeeks
GFG

例3：

                     // Implementation of Stream.concat()                   
                     // method in Java 8 with DoubleStream                   
                     import                               java.util.*;                   
                     import                               java.util.stream.Stream;                   
                     import                               java.util.stream.DoubleStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                             
                                         // Creating two Streams                   
                                         DoubleStream Stream1 = DoubleStream.of(                               1520                               ,                               1620                               );                   
                                         DoubleStream Stream2 = DoubleStream.of(                               1720                               ,                               1820                               );                   
                             
                                         // concatenating both the Streams and                   
                                         // displaying the result                   
                                         DoubleStream.concat(Stream1, Stream2)                   
                                         .forEach(element -> System.out.println(element));                   
                                         }                   
                     }                   

输出：

例4：

                     // Implementation of Stream.concat()                   
                     // method in Java 8 and removing                   
                     // the duplicates                   
                     import                               java.util.*;                   
                     import                               java.util.stream.IntStream;                   
                     import                               java.util.stream.Stream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                             
                                         // Creating two Streams                   
                                         Stream<String> stream1 = Stream.of(                               "Geeks"                               ,                               "for"                               ,                               "GeeksforGeeks"                               );                   
                                         Stream<String> stream2 = Stream.of(                               "GeeksQuiz"                               ,                               "GeeksforGeeks"                               ,                               "for"                               );                   
                             
                                         // concatenating both the Streams                   
                                         // with Stream.concat() function                   
                                         // and displaying the result after                   
                                         // removing the duplicates                   
                                         Stream.concat(stream1, stream2).distinct().forEach(element -> System.out.println(element));                   
                                         }                   
                     }                   

输出：

Geeks
for
GeeksforGeeks
GeeksQuiz

例5：

                     // Implementation of Stream.concat()                   
                     // method in Java 8 with LongStream                   
                     import                               java.util.*;                   
                     import                               java.util.stream.Stream;                   
                     import                               java.util.stream.LongStream;                   
                             
                     class                               GFG {                   
                             
                                         // Driver code                   
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                             
                                         // Creating two Streams                   
                                         LongStream Stream1 = LongStream.of(                               1520                               ,                               1620                               );                   
                                         LongStream Stream2 = LongStream.of(                               1720                               ,                               1820                               );                   
                             
                                         // concatenating both the Streams and                   
                                         // displaying the result                   
                                         LongStream.concat(Stream1, Stream2)                   
                                         .forEach(element -> System.out.println(element));                   
                                         }                   
                     }                   

输出：

文章版权归作者所有，未经允许请勿转载。

THE END

Java