1.6.1. Stream Creation

List<String> names = Arrays.asList("John", "Jane", "Jack");
Stream<String> stream = names.stream();

To create a stream in Java, you typically start with a collection, such as a List. In this case, we have a list of names ("John", "Jane", "Jack"). By calling the stream() method on this list, we convert it into a Stream of strings. A stream allows you to perform various operations on the collection elements in a functional style, such as transformations or filtering.

Imagine you have a stack of books on a table. Instead of looking at each book one by one (which can take a lot of time), you decide to create a catalog (the stream) where you can easily search and reference the books without moving them around. The stream acts as a way to work with the list efficiently.

• map(): transform data
• filter(): filter data based on a condition
• forEach(): apply action to each element
• reduce(): reduce to a single result
• collect(): collect elements into a container (e.g., List)

Once you have a stream, you can perform various operations on it. Each operation transforms the stream in some way. For example, map() is used to apply a function to each element, transforming it into something else, while filter() is for filtering out elements that don’t meet a certain condition. forEach() is for performing an action on each element, reduce() is to combine all elements into a single result, and collect() is to collect all processed elements back into a list or another collection.

Think of a stream like a conveyor belt in a factory. Each operation on the stream is like a station along the conveyor belt. The map() station may modify the items, the filter() station might remove unwanted items, the forEach() station might perform checks on the items, and finally, the collect() station gathers everything that passed through the line and puts it into boxes.

List<String> names = Arrays.asList("John", "Jane", "Jack");
names.stream()
    .filter(name -> name.startsWith("J"))
    .map(String::toUpperCase)
    .forEach(System.out::println);

In this example, we take a list of names and create a stream from it. We then apply the filter() method to choose only those names that start with the letter 'J'. After filtering, we use map() to convert all remaining names to uppercase. Finally, we apply forEach() to print each name to the console. This process demonstrates how streams work together to process data in a clean and concise way.

Consider a fruit market where you only want to display ripe oranges. First, you sort through all the fruits (stream), remove anything that isn’t an orange (filter), then paint all the oranges bright orange (map), and finally, you shout out the names of the ripe oranges for customers (forEach). This pipeline of actions is similar to how we process streams in Java.

--