Stream.concat() method creates a concatenated stream in which the elements are all the elements of the first stream followed by all the elements of the second stream. The resulting stream is ordered if both of the input streams are ordered, and
parallel if either of the input streams is parallel.
Syntax :
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
The calls to Stream.concat(stream1, stream2) can be think of as forming a binary tree. The concatenation of all the input streams is at the root. The individual input streams are at the leaves. Below given are some examples of trees upto four input streams a, b, c and d.
For two streams a and b, the tree looks like :
For three streams a, b and c, the tree looks like :
For four streams a, b, c and d, the tree looks like :
Each additional input stream adds one layer of depth to the tree and one layer of indirection to reach all the other streams.
Note : The elements returned by Stream.concat() method is ordered. For example, the following two lines returns the same result:
Stream.concat(Stream.concat(stream1, stream2), stream3);
Stream.concat(stream1, Stream.concat(stream2, stream3));
But the result for the following two are different.
Stream.concat(Stream.concat(stream1, stream2), stream3);
Stream.concat(Stream.concat(stream2, stream1), stream3);
Below are some examples to understand the implementation of the function in a better way.
Example 1 :
Java
// 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));
}
}
Output:
Geeks
for
GeeksQuiz
GeeksforGeeks
Example 2 :
Java
// 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));
}
}
Output:
Geeks
GeeksQuiz
GeeksforGeeks
GFG
Example 3 :
Java
// 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));
}
}
Output:
1520.0
1620.0
1720.0
1820.0
Example 4 :
Java
// 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));
}
}
Output:
Geeks
for
GeeksforGeeks
GeeksQuiz
Example 5 :
Java
// 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));
}
}
Output:
1520
1620
1720
1820
Similar Reads
Stream In Java Stream was introduced in Java 8, the Stream API is used to process collections of objects. A stream in Java is a sequence of objects that supports various methods that can be pipelined to produce the desired result. Use of Stream in JavaThe uses of Stream in Java are mentioned below:Stream API is a
7 min read
Convert Stream to Set in Java Below given are some methods which can be used to convert Stream to Set in Java. Method 1 : Using Collectors Stream collect() method takes elements from a stream and stores them in a collection.collect(Collector.toSet()) collects elements from a stream to a Set. Stream.collect() method can be used t
3 min read
Convert a Set to Stream in Java Set interface extends Collection interface and Collection has stream() method that returns a sequential stream of the collection. Below given are some examples to understand the implementation in a better way. Example 1 : Converting Integer HashSet to Stream of Integers. Java // Java code for conver
2 min read
Array to Stream in Java Prerequisite : Stream In Java Using Arrays.stream() : Syntax : public static <T> Stream<T> getStream(T[] arr) { return Arrays.stream(arr); } where, T represents generic type. Example 1 : Arrays.stream() to convert string array to stream. Java // Java code for converting string array // t
3 min read
IntStream concat() in Java IntStream concat() method creates a concatenated stream in which the elements are all the elements of the first stream followed by all the elements of the second stream. The resulting stream is ordered if both of the input streams are ordered, and parallel if either of the input streams is parallel.
2 min read
Java 8 Stream Introduction to Stream, Java Intstream, Jaa Longstream , Java DoublestreamanyMatch() noneMatch() mapToLong() findAny()forEachOrdered() forEach() allMatch() filter() findFirst() flatMapToInt() mapToInt() map() peek() counting()Iterator()Generate()Skip()SummaryStatistics()Builder()Empty()Stream toArra
1 min read
Java Stream API – Filters In this article, we will learn Java Stream Filter API. We will cover, 1. How stream filter API works. 2. Filter by Object Properties. 3. Filter by Index. 4. Filter by custom Object properties. Stream Filter API Filter API takes a Predicate. The predicate is a Functional Interface. It takes an argume
5 min read
Convert List to Set in Java Java Set is a part of java.util package and extends java.util.Collection interface. It does not allow the use of duplicate elements and at max can accommodate only one null element. Few important features of the Java Set interface are as follows: The set interface is an unordered collection of objec
5 min read
Convert an Iterable to Stream in Java Given an Iterable, the task is to convert it into Stream in Java. Examples: Input: Iterable = [1, 2, 3, 4, 5] Output: {1, 2, 3, 4, 5} Input: Iterable = ['G', 'e', 'e', 'k', 's'] Output: {'G', 'e', 'e', 'k', 's'} Approach: Get the Iterable. Convert the Iterable to Spliterator using Iterable.spliterat
1 min read
Convert an Iterator to Stream in Java Given an Iterator, the task is to convert it into Stream in Java. Examples: Input: Iterator = {1, 2, 3, 4, 5} Output: {1, 2, 3, 4, 5} Input: Iterator = {'G', 'e', 'e', 'k', 's'} Output: {'G', 'e', 'e', 'k', 's'} Approach: Get the Iterator. Convert the iterator to Spliterator using Spliterators.split
1 min read