1. Introduction to Streams
In this video, we'll explore `Streams`, a powerful tool that makes data processing easier by applying functional operations directly to collections.
We'll see how `Streams` can efficiently filter, count, and process data with minimal code, making complex operations more readable and concise.
2. Working with Streams
Java `Stream` API enables functional-style operations on collections without modifying the original data. Streams work with `List`, `Set`, and even `Maps` - by processing keys, values, or entries separately. We can also stream arrays using `Arrays.stream()`.
To demonstrate `Streams`, we will use an `ArrayList` named `names`, containing `Alice`, `Bob`, `Charlie`, and `David`, a simple yet flexible list used in many real-world applications, such as sorting, filtering, formatting, and data transformation.
3. Using lambda expressions with Stream
`Streams` often require applying transformations or actions to elements. `Lambda expressions` provide a concise way to define these operations inline.
We provide the parameters, in brackets, followed by and an arrow, and the expression in curly brackets. If we have only one parameter or the expression is short, we can also omit the brackets. Overall, the syntax makes it easy to apply logic inline.
In this example, `.forEach()` iterates through the previously created list `names` and applies the lambda expression.
`name` represents each element in the list.
`System.out.println(name)` executes for each element, printing them line by line.
4. Creating a Stream
To use `Streams`, we can convert a list using `.stream()`, enabling functional operations.
`Streams` work with multiple collection types, including `List`, `Set`, and `Queue`.
Before using `Streams`, we need to import the `Stream` class from `java.util.stream`. Since these are part of Java’s standard library, no installation is needed.
In this example, we used the sample list `names` we created earlier. We call `.stream()` on names, storing the result in a `Stream` object.
Then, we use `.forEach()` to process and print each element.
5. Filtering data with Streams
The `.filter()` method allows selecting elements based on a condition. Here is how it works.
First, we call `.stream()` on `names` to create a `Stream` object.
Then, we use `.filter()` with a condition that keeps only names that start with `A`.
Finally, we use `forEach()` to print the result. In this case, the only matching element is `Alice`.
6. Counting elements with Streams
The `.count()` method returns the total number of elements that match a condition.
First, we call `.stream()` on names, storing the result in a `Stream` object.
Then, we use `.filter()` with a condition that keeps only names that start with `B`.
Finally, we call `.count()` to count the element that match the condition.
The output shows 1, meaning one name in the list meets the condition.
This method is useful for quick data analysis without manual counting.
7. When to use Streams
`Streams` are ideal for large datasets, as they reduce performance overhead by supporting parallel processing. They are especially useful for filtering, mapping, and transforming data efficiently.
However, Streams are not meant for modifying the original collection - they are designed for processing, not mutation.
Knowing when to use `Streams` helps us write efficient, maintainable code.
8. Let's practice!
Now it's your turn to practice!