10 Ways to Create a Stream in Java

Collections of objects can be processed using the Stream API, which was first released in Java 8. A stream is a collection of items that can be pipelined in a variety of ways to achieve distinct outcomes.

Java Stream's characteristics are:

As an alternative to receiving input via arrays, collections, or I/O channels, a stream is not a data structure.
Only the result of pipelined techniques is provided by streams; the underlying data structure is not altered.
It is possible to pipe line different intermediary operations since they are all performed lazily and result in streams. At the end of the stream, a terminal operation marks the outcome and returns it.

The different approaches for creating the streams:

Approach: Using the Collections

Algorithm:

Step 1: Obtain the collection

Step 2: Use the Collection.stream() function to create a Sequential Stream from the collection.

Step 3: Print the Stream

Implementation:

FileName: SequentialStream.java

import java.util.*; 
import java.util.*;
import java.util.stream.Stream;
public class SequentialStream 
{ 
    // Function to create a stream from a list 
    private static <T> void getStream(List<T> list) 
    { 
        // Use the List to create a stream object. 
        Stream<T> stream = list.stream(); 
        // Repeat the list from the start to the last element 
        Iterator<T> it = stream.iterator(); 
        // Iterate through the stream object 
        while (it.hasNext()) 
        { 
            System.out.print(it.next() + " "); 
        } 
    } 
    public static void main(String[] args) 
    { 
        // Create and Initialize the ArrayList of String 
        List<String> my_list = new ArrayList<>(); 
        // Addition of elements to the list 
        my_list.add("Hello"); 
        my_list.add("Welcome"); 
        my_list.add("to");
        my_list.add("the"); 
        my_list.add("World!"); 
        // Obtain the Stream via the List. 
        getStream(my_list); 
    } 
}

Output:

Hello Welcome to the World!

Approach: Create a stream from specified values

The t values can be used to build a stream using the Stream.of(T…t) method, where t are the elements. A sequential Stream with the t elements is the result of this method.

Implementation:

FileName: StreamSpecifiedValues.java

import java.util.*; 
import java.util.stream.Stream; 
import java.io.*;
public class StreamSpecifiedValues 
{ 
	// Function to create a stream from a list 
	private static void getStream() 
	{ 
		// Construct a stream using the given values. 
		Stream<Integer> stream = Stream.of( 11, 22, 33, 44, 55, 66, 77, 88, 99); 
		// displaying the stream that is arranged sequentially 
		stream.forEach(p -> System.out.print(p + " ")); 
	} 
	public static void main(String[] args) 
	{ 
		// Utilize the values to get the stream. 
		getStream(); 
	} 
}

Output:

11 22 33 44 55 66 77 88 99

Approach: Create a stream using Arrays.stream()

A sequential stream can be created from a specified array using the Stream.of() and Arrays.stream() methods, which are often used. When a non-primitive type T is used to invoke either of these methods, a Stream is returned.

Implementation:

FileName: ArrayStream.java

import java.util.*; 
import java.util.stream.Stream; 
import java.io.*;
public class ArrayStream 
{ 
	// Function to create a stream from a list 
	private static <T> void getStream(T[] a) 
	{ 
		// Using Arrays.stream(), 
		// create a stream from an array. 
		Stream<T> Array = Arrays.stream(a); 
		// Repeat the list from the start to the last element 
		Iterator<T> iterate = Array.iterator(); 
		// Iterate through stream object 
		while (iterate.hasNext()) 
		{ 
			System.out.print(iterate.next() + " "); 
		} 
	} 
	public static void main(String[] args) 
	{ 
		// intitalizing and creating the array 
		String[] a = new String[] { "Hello", "Welcome", "to", "World!" }; 
		//  Get the Stream out of the Array.
		getStream(a); 
	} 
}

Output:

Hello Welcome to World!

Approach: Create a stream using Stream.of()

A non-interfering action that returns a new stream while also being applied to components as they are taken in from the stream.

Implementation:

FileName: StreamOFCreation.java

import java.util.*; 
import java.util.stream.Stream; 
import java.io.*;
public class StreamOFCreation 
{ 
	// Function to create a stream from a list 
	private static <T> void getStream(T[] a) 
	{ 
		// Use Stream.of() to create a stream from an array. 
		Stream<T> Array = Stream.of(a); 
		// Repeat the list from the start to the last element 
		Iterator<T> it = Array.iterator(); 
		// Iterate through the stream object 
		while (it.hasNext()) 
		{ 
			System.out.print(it.next() + " "); 
		} 
	} 
	public static void main(String[] args) 
	{ 
		//Create and initialize the array 
		String[] a = new String[] { "Hello", "Welcome", "to", "World!" }; 
		// Get the stream by accessing the array. 
		getStream(a); 
	} 
}

Output:

Hello Welcome to World!

Approach: Create a Stream using Stream.builder()

The build() method will generate an instance of the Stream; otherwise, the builder() method is used when the desired type needs to be explicitly given in the correct part of the statement.

Implementation:

FileName: StreamStringBuilder.java

import java.util.*; 
import java.util.stream.Stream; 
import java.io.*;
public class StreamStringBuilder 
{ 
	// Function to create a stream from a list 
	private static <T> void getStream() 
	{ 
		// Use Stream builder() to create a stream. 
		Stream.Builder<String> strbuild = Stream.builder(); 
		// Adding elements into the Strings stream 
		Stream<String> str_stream = strbuild.add("Hello") 
		.add("Welcome") 
		.add("to the") 
		.add("World!") 
		.build(); 
		// Repeat from the first to the last element in the list. 
		Iterator<String> iterate = str_stream.iterator(); 
		// Repeat stream object iterations 
		while (iterate.hasNext()) 
		{ 
			System.out.print(iterate.next() + " "); 
		} 
	} 
	public static void main(String[] args) 
	{ 
		// Use Builder to obtain the Stream 
		getStream(); 
	} 
}

Output:

Hello Welcome to the World!

Approach: Create an infinite Stream using Stream.iterate()

An infinite sequential ordered stream is returned by the iterate() method, which is created by repeatedly applying a function f to a seed element. The first parameter of the iterate method is the first element of the resultant stream in the example below. The function is applied to the preceding element in order to create each subsequent element.

Implementation:

FileName: IterateStream.java

import java.util.*; 
import java.util.stream.Stream; 
import java.io.*;
public class IterateStream 
{ 
	// Function to create a stream from a list 
	private static <T> void
	getStream(int seedValue, int limitTerms) 
	{ 
		// Use the Stream.iterate() method to 
		// create an infinite stream. 
		Stream.iterate(seedValue, (Integer n) -> n * n) 
			.limit(limitTerms) 
			.forEach(System.out::println); 
	} 
	public static void main(String[] args) 
	{ 
		// Retrieve the seed value. 
		int seedValue = 3; 
		// Determine the limit for the number of terms. 
		int limitTerms = 7; 
		// Retrieve the Stream using the method 
		getStream(seedValue, limitTerms); 
	} 
}

Output:

Approach: Create an infinite Stream using Stream.generate() method

The generated stream is limitless and can be generated by the generate() method, which takes as a given input. Hence, to limit it, either give the size we want or let the generate() method run until the memory limit is reached.

Implementation:

FileName: GenerateStream.java

import java.util.*; 
import java.util.*; 
import java.util.stream.*; 
import java.io.*;
public class GenerateStream 
{ 
	// Function to create a stream from a list 
	private static <T> void getStream(int limit) 
	{ 
		// Utilizing the Stream.generate() method, 
		//Create an infinite stream 
		Stream.generate(Math::random) 
			.limit(limit) 
			.forEach(System.out::println); 
	} 
	public static void main(String[] args) 
	{ 
		// Determine the limit for the number of terms. 
		int limit = 6; 
		// Retrieve the Stream using the method 
		getStream(limit); 
	} 
}

Output:

0.8285302774864066
0.6259903293195835
0.28498534663189434
0.06681813318465979
0.6526779164446666
0.36696884550384856

Approach: Create a stream from a Pattern using a Predicate

A boolean-valued predicate function is created in Java 8 through the Predicate asPredicate() method of Pattern and is utilized for pattern matching.

Implementation:

FileName: StreampatternPredicate.java

import java.util.*; 
import java.util.stream.*; 
import java.util.regex.Pattern; 
import java.io.*;
public class StreampatternPredicate
{
	// Function convert a List into Stream 
	private static void
	getStream(List<String> my_list, Pattern pat) 
	{ 
		my_list.stream() 
		.filter(pat.asPredicate()) 
		.forEach(System.out::println); 
	} 
	public static void main(String[] args) 
	{ 
		// Create ArrayList of String 
		// that is backed by the specified array 
		List<String> my_list = Arrays .asList("Hello", "Welcome", "to", "the", "World" ); 
		// Get the pattern 
		Pattern pat = Pattern.compile("^t"); 
		// Get the Stream from the List matching Pattern 
		getStream(my_list, pat); 
	} 
}

Output:

to
the

Approach: Create a stream from the Iterator

The Collection Framework uses Java iterators to get elements one at a time. The sequential stream can only be created with the help of the splitterator. Thus, a Spliterator is additionally used in this technique. However, in this case, an Iterable that is created from the Iterator is used as the Spliterator's source. Therefore, the Iterator is used to build the Iterable first. Next, the Spliterator is given directly as Iterable.spliterator() to the stream() method.

Implementation:

FileName: IteratorStream.java

import java.util.*; 
import java.util.stream.*; 
import java.io.*;
public class IteratorStream 
{ 
	// Convert a List to Stream using this function 
	private static <T> void getStream(Iterator<T> itr) 
	{ 
		// Create a Spliterator from the iterator. 
		Spliterator<T> spiterate = Spliterators .spliteratorUnknownSize(itr, Spliterator.NONNULL); 
		// Create a sequential stream from the splitterator. 
		Stream<T> stream = StreamSupport.stream(spiterate, false); 
		// Repeat the list from the start to the last element 
		Iterator<T> iterate = stream.iterator(); 
		// Iterating through stream object 
		while (iterate.hasNext()) 
		{ 
			System.out.print(iterate.next() + " "); 
		} 
	}
	public static void main(String[] args) 
	{ 
		// create and initialize the Iterator 
		Iterator<String> iterate = Arrays .asList("Hello", "Welcome", "to", "World!") .iterator(); 
		// Retrieve the Stream from the Loop 
		getStream(iterate); 
	} 
}

Output:

Hello Welcome to World!

Approach: Create a stream from Iterable

Since iterable interfaces are not meant to have their own stream() method, they are designed with this in mind. All that needs to be done is pass it into the StreamSupport.stream() function to obtain a stream from the supplied Iterable object. Converting an Iterable to a Stream is simpler. Spliterator(), the default method of Iterable, can be used to obtain an instance of Spliterator, which can then be transformed into a Stream.

Note: The Iterable is not an instance of Collection; rather, this method calls the Collection.stream() method internally when it has to obtain a sequential stream from the Spliterator. Otherwise, it is called StreamSupport.stream().

Implementation:

FileName: IterableStream.java

import java.io.*;
import java.util.*;
import java.util.stream.*;
public class IterableStream 
{
    // Function to create a stream from a list
    private static <T> void getStream(Iterable<T> iter) 
    {
        // Create a stream out of the iterable.
        Stream<T> str = StreamSupport.stream(iter.spliterator(), false);
        // Repeat the list from the start to the last element
        Iterator<T> iterate = str.iterator();
        // Iterating through the stream object
        while (iterate.hasNext()) 
        {
            System.out.print(iterate.next() + " ");
        }
    }
    public static void main(String[] args) 
    {
        // Create and initialize the Iterable
        List<String> iter = Arrays.asList("Hello", "Welcome", "to", "World!");
        // Retrieve the Stream from the Iterable
        getStream(iter);
    }
}

Output: