Stream API in Java provides a powerful way to work with collections and other data sources. Mapping is one of the key operations available in the Stream API, used to transform elements of a stream. Here's a step-by-step guide on how to use the map function with the Stream API:
Import Required Classes :

Create a Stream:
You can create a stream from various sources, like collections, arrays, or generator functions. For example, creating a stream from a list:
Apply the map Function:
Use the map function to transform each element of the stream. For instance, to convert each name to uppercase:
Collect the Results:
Finally, you can collect the transformed stream back into a list or another collection:
Complete Example:
Here’s a complete example demonstrating how to use the map function with the Stream API:
import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class StreamMapExample { public static void main(String[] args) { // Create a list of names List<String> names = Arrays.asList("a14mk", "manoj", "Jack"); // Convert the list to a stream List<String> upperCaseNames = names.stream() // Apply the map function to transform each name to uppercase .map(String::toUpperCase) // Collect the results back into a list .collect(Collectors.toList()); // Print the transformed list upperCaseNames.forEach(System.out::println); } }
Mapping with Complex Objects:
If you are working with a list of objects, you can use the map function to transform specific fields or create new objects. For example:
import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; class Person { String name; int age; Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } public class StreamMapExample { public static void main(String[] args) { // Create a list of persons List<Person> people = Arrays.asList( new Person("a14mk", 25), new Person("manoj", 30), new Person("Jack", 35) ); // Transform the list to get a list of names List<String> names = people.stream().map(Person::getName).collect(Collectors.toList()); // Print the list of names names.forEach(System.out::println); } }
In this example, the map function is used to extract the names from a list of Person objects.

Let's begin by defining the term stream as it applies to the stream API:
A stream operates on a data source, such as an array or a collection. A stream, itself, never provides storage on a data. It simply moves data, possibly filtering, sorting, or otherwise operating on that data is the process. as a genral rule, however a stream operation by itself does not modyfy the data source. For Example: sorting a stream does not change the order of the source. Rather, sorting a stream results in the creation of a new stream that produces the sroted result.
A Simple Stream Example : Let's work through an example that uses streams. The following program creates an ArrayList called myList that holds a collection of integers. Next, it obtains a stream that uses myList as a source.

package streamclasses; import java.util.ArrayList; import java.util.Optional; import java.util.stream.Stream; /** * * @author manoj.vishwakarma */ public class StreamClassDemo { public static void main(String[] args) { //Create a list of integer Values ArrayList<Integer> myList=new ArrayList<Integer>(); myList.add(7); myList.add(18); myList.add(10); myList.add(5); myList.add(24); myList.add(17); myList.add(5); System.out.println("Original Lise:" +myList); //Obtain a stream to the array list. Stream<Integer> myStream=myList.stream(); //Obtain the minimum and maximum value by using of min(), max(), isPresent(), and get() Optional<Integer> minValu=myStream.min(Integer::compare); if(minValu.isPresent()){ System.out.println("Minimum Value:"+minValu.get()); } // Must obtain a new stream because previous call to min() is a terminal opration that consumed the stream //Max value myStream=myList.stream(); Optional<Integer> maxValu=myStream.max(Integer::compare); if(maxValu.isPresent()){ System.out.println("Max Value:"+maxValu.get()); } //Sort the stream by use of sorted() Stream<Integer> sortStream=myList.stream().sorted(); //Display the sorted stream by use of forEacg(). System.out.println("Sorted stream"); sortStream.forEach((n)->System.out.println(n+"")); //Dispaly only the odd values by use of filter() Stream<Integer> oddValue=myList.stream().sorted().filter((n)->(n%2)==1); //Display the sorted stream by use of forEacg(). System.out.println("Odd Values"); oddValue.forEach((n)->System.out.println(n+"")); //Display only the odd value that are greater than 5. Notice That two filter operations are pipelined oddValue=myList.stream().sorted().filter((n)->(n%2)==1) .filter((n)->n>5); System.out.println("Odd Values grater than 5:"); oddValue.forEach((n)->System.out.println(n+"")); } }
OUTPUT: