Welcome back! In this article, we’re diving into the realm of functional programming with Java and exploring various methods to create bounded streams. You might recall that we’ve already delved into the basics of stream creation, such as using the Stream call on a collection. In this lecture, we’ll expand our knowledge to tackle various scenarios for creating bounded streams.
Table of contents
Open Table of contents
Sections
Introduction to Bounded Streams
In functional programming, streams are an integral concept, providing a versatile way to work with sequences of elements. Streams are particularly useful for processing large datasets, collections, and more. However, in some cases, we may need to work with only a portion of the data, which brings us to the concept of bounded streams.
A bounded stream refers to a stream that contains a limited number of elements, or in other words, it has a boundary. Creating such streams is essential for efficient memory utilization and optimized processing. In this article, we’ll explore different methods to create bounded streams in Java.
Method 1: Stream Creation from Collections
We’re already familiar with creating streams from collections. For instance, invoking the stream method on a collection provides a stream containing all the elements present in that collection. Let’s revisit this technique:
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
Stream<Integer> numberStream = numbers.stream();
Method 2: Streaming Entries from a Map
Maps are a bit different due to their key-value pairs. To stream the entries, keys, or values of a map, we can use methods like entrySet, keySet, and values. Let’s see how this works:
Map<Integer, String> keyValueMap = Map.of(1, "One", 2, "Two", 3, "Three");
Stream<Map.Entry<Integer, String>> entryStream = keyValueMap.entrySet().stream();
Stream<Integer> keyStream = keyValueMap.keySet().stream();
Stream<String> valueStream = keyValueMap.values().stream();
Method 3: Stream Creation using ‘Stream.of’
Another approach is to use the Stream.of method. This method allows us to generate a stream with specified values. It’s a static method that accepts a variable number of arguments. Here’s how we can create a stream of strings using this method:
Stream<String> stringStream = Stream.of("Apple", "Banana", "Cherry");
Method 4: Using Arrays.stream for Arrays
Just like we used stream for collections, we can use Arrays.stream for arrays. This method allows us to create a stream from array elements. Note that it returns an IntStream for primitive int arrays:
int[] intArray = {1, 2, 3, 4, 5};
IntStream intStream = Arrays.stream(intArray);
Method 5: Builder Pattern for Stream Creation
The fourth approach involves a more flexible technique. We can create a stream builder, add elements as needed, and then invoke the build method to obtain the stream. This approach is beneficial when we need to add elements conditionally or manipulate the stream creation process:
Stream.Builder<Integer> integerStreamBuilder = Stream.builder();
integerStreamBuilder.add(1).add(2).add(3);
Stream<Integer> builtStream = integerStreamBuilder.build();
The Grand Finale
In this article, we’ve delved into the realm of bounded streams in functional programming using Java. We’ve explored various approaches to create bounded streams, including utilizing collections, maps, Stream.of, Arrays.stream, and even leveraging the builder pattern for flexible stream creation.
Understanding these methods to create bounded streams is crucial for efficient data processing and memory utilization in functional programming with Java. By mastering these techniques, you’ll be well-equipped to handle different scenarios and unleash the power of streams in your applications. In the next lecture, we’ll take a step further and explore how to create infinite streams – an intriguing topic in the world of functional programming. Stay tuned!
You can find the repo for this section of the course Here