Java Stream map() Tutorial 🚀

Welcome to our comprehensive guide on the map() function in Java Stream API! By the end of this tutorial, you'll have a solid understanding of how to use map() in your Java projects. Let's dive right in!

What is Java Stream map()? 💡

The map() function is a part of the Java Stream API and is used to transform the elements of a Stream. It applies a provided function to each element of the stream, creating a new Stream with the transformed elements.

Why use Java Stream map()? 📝

map() is useful when you want to modify the elements of a Stream without modifying the original data structure. It provides a functional programming approach that can help make your code cleaner, more concise, and easier to reason about.

How to use Java Stream map() 🎯

Basic Example

First, let's create a simple example using a List of integers:

java

import java.util.Arrays;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // Initialize a list of integers
        int[] numbers = {1, 2, 3, 4, 5};

        // Convert the list to a Stream
        Stream<int[]> stream = Stream.of(numbers);

        // Apply a mapping function to each element
        Stream<Integer> mappedStream = stream.map(arr -> arr[0] * 2);

        // Collect the results into a List
        List<Integer> doubledNumbers = mappedStream.collect(Collectors.toList());

        System.out.println(doubledNumbers); // Output: [2, 4, 6, 8, 10]
    }
}

In this example, we're creating a Stream of integers, applying a mapping function (multiplication by 2) to each element, and collecting the results into a List.

Real-world Example

Now, let's apply map() to a more practical scenario: converting a Stream of Person objects to a Stream of their ages.

java

import java.time.LocalDate;
import java.util.Arrays;
import java.util.stream.Stream;

class Person {
    private String name;
    private LocalDate birthDate;

    // Constructors, getters, and setters omitted for brevity
}

public class Main {
    public static void main(String[] args) {
        // Initialize a list of Person objects
        Person[] people = new Person[]{
            new Person("Alice", LocalDate.of(1990, 1, 1)),
            new Person("Bob", LocalDate.of(1985, 2, 2)),
            // ... more Person objects ...
        };

        // Convert the list to a Stream
        Stream<Person> peopleStream = Stream.of(people);

        // Map the Stream to a Stream of ages
        Stream<Integer> agesStream = peopleStream.map(person -> person.getBirthDate().getYear());

        // Collect the results into a List
        List<Integer> ages = agesStream.collect(Collectors.toList());

        System.out.println(ages); // Output: [1990, 1985, ...]
    }
}

In this example, we're creating a Stream of Person objects, mapping each person to their age, and collecting the results into a List.

Quiz Time 🎲

Advanced Example 🌟

Now, let's take our practical example to the next level by calculating the average age of the people in our list.

java

import java.time.LocalDate;
import java.util.Arrays;
import java.util.stream.Stream;
import java.util.stream.Collectors;

class Person {
    private String name;
    private LocalDate birthDate;

    // Constructors, getters, and setters omitted for brevity
}

public class Main {
    public static void main(String[] args) {
        // Initialize a list of Person objects
        Person[] people = new Person[]{
            new Person("Alice", LocalDate.of(1990, 1, 1)),
            new Person("Bob", LocalDate.of(1985, 2, 2)),
            // ... more Person objects ...
        };

        // Convert the list to a Stream
        Stream<Person> peopleStream = Stream.of(people);

        // Map the Stream to a Stream of ages
        Stream<Integer> agesStream = peopleStream.map(person -> person.getBirthDate().getYear());

        // Calculate the average age
        double averageAge = agesStream.mapToInt(age -> age).average().orElse(0);

        System.out.println("The average age is: " + averageAge);
        // Output: The average age is: [some decimal value]
    }
}

In this example, we're calculating the average age by first mapping the Stream of Person objects to a Stream of ages, then converting the Stream of ages to an IntStream, and finally calculating the average using the average() function.

And there you have it! You now have a solid understanding of the map() function in Java Stream API. Happy coding! 🎉