Java 8 Lambda: Convert List to Another List

Java 8 introduced lambda expressions, which are a powerful addition to the Java language. One of the common use-cases of lambda expressions is to convert one list into another list. This operation is often required in various programming scenarios, such as data transformation, filtering, and mapping. In this blog post, we will explore how to use Java 8 lambda expressions to convert a list to another list, including core concepts, typical usage scenarios, common pitfalls, and best practices.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Code Examples
  4. Common Pitfalls
  5. Best Practices
  6. Conclusion
  7. FAQ
  8. References

Core Concepts#

Lambda Expressions#

Lambda expressions in Java 8 are a concise way to represent an anonymous function. They can be used to implement functional interfaces, which are interfaces with a single abstract method. For example, the java.util.function.Function interface is a functional interface that represents a function that takes one argument and produces a result.

Stream API#

The Stream API in Java 8 provides a powerful way to process collections of data. A stream is a sequence of elements that can be processed in a functional-style. The Stream interface provides methods like map(), filter(), and collect() that can be used to perform various operations on the elements of a list.

Mapping#

Mapping is the process of transforming each element of a list into another element. In the context of converting a list to another list, we use the map() method of the Stream interface. The map() method takes a Function as an argument and applies this function to each element of the stream.

Collecting#

After performing operations on the elements of a stream, we need to collect the results into a new list. We use the collect() method of the Stream interface, along with the Collectors.toList() method to collect the elements of the stream into a new List.

Typical Usage Scenarios#

Data Transformation#

Suppose you have a list of integers and you want to create a new list where each integer is squared. You can use lambda expressions and the Stream API to perform this transformation.

Filtering and Transformation#

You may have a list of objects and you want to filter out some objects based on a certain condition and then transform the remaining objects. For example, you have a list of employees and you want to create a new list of employee names for those employees who have a salary greater than a certain amount.

Object to Primitive Conversion#

If you have a list of objects that contain primitive values (e.g., a list of IntegerWrapper objects that contain int values), you can convert this list into a list of primitive values.

Code Examples#

Example 1: Squaring a list of integers#

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class SquareListExample {
    public static void main(String[] args) {
        // Create a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
 
        // Use lambda and Stream API to square each number and collect into a new list
        List<Integer> squaredNumbers = numbers.stream()
                .map(num -> num * num) // Map each number to its square
                .collect(Collectors.toList());
 
        System.out.println("Original list: " + numbers);
        System.out.println("Squared list: " + squaredNumbers);
    }
}

In this example, we first create a list of integers. Then we use the stream() method to convert the list into a stream. We apply the map() method with a lambda expression num -> num * num to square each number in the stream. Finally, we use the collect() method with Collectors.toList() to collect the squared numbers into a new list.

Example 2: Filtering and transforming a list of employees#

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
class Employee {
    private String name;
    private double salary;
 
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
 
    public String getName() {
        return name;
    }
 
    public double getSalary() {
        return salary;
    }
}
 
public class EmployeeFilteringExample {
    public static void main(String[] args) {
        // Create a list of employees
        List<Employee> employees = Arrays.asList(
                new Employee("Alice", 5000),
                new Employee("Bob", 6000),
                new Employee("Charlie", 4000)
        );
 
        // Filter employees with salary > 5000 and get their names
        List<String> filteredEmployeeNames = employees.stream()
                .filter(employee -> employee.getSalary() > 5000)
                .map(Employee::getName)
                .collect(Collectors.toList());
 
        System.out.println("Filtered employee names: " + filteredEmployeeNames);
    }
}

In this example, we have a list of Employee objects. We first filter the employees whose salary is greater than 5000 using the filter() method. Then we use the map() method with a method reference Employee::getName to extract the names of the filtered employees. Finally, we collect the names into a new list.

Common Pitfalls#

Null Pointer Exceptions#

If the elements of the original list can be null, applying a lambda expression that tries to access a method or field of these elements can result in a NullPointerException. You should handle null values either by filtering them out before applying the lambda expression or by using conditional logic inside the lambda expression.

Incorrect Use of Stream Operations#

If you use the map() and filter() methods in the wrong order, you may not get the expected results. For example, if you want to filter out null values and then perform a transformation, you should filter first and then map.

Not Closing Streams (in some cases)#

Although most of the time, Java's garbage collector takes care of closing the streams, in some cases (e.g., when working with I/O streams), you need to explicitly close the streams to avoid resource leaks.

Best Practices#

Handle Null Values#

Before applying operations on the elements of a stream, filter out null values using the filter() method. For example:

List<String> originalList = Arrays.asList("apple", null, "banana");
List<String> newList = originalList.stream()
        .filter(str -> str != null)
        .map(str -> str.toUpperCase())
        .collect(Collectors.toList());

Use Method References when Appropriate#

If the lambda expression simply calls an existing method, use a method reference instead. Method references make the code more concise and readable. For example, instead of employee -> employee.getName(), use Employee::getName.

Keep the Lambda Expressions Simple#

Lambda expressions should be short and simple. If a lambda expression becomes too complex, consider refactoring it into a separate method and use a method reference.

Conclusion#

Java 8 lambda expressions and the Stream API provide a powerful and concise way to convert a list to another list. By understanding the core concepts of lambda expressions, the Stream API, mapping, and collecting, you can handle various data transformation and filtering scenarios. However, you need to be aware of common pitfalls and follow best practices to write robust and maintainable code.

FAQ#

Q1: Can I use lambda expressions to convert a list to a different type of collection (e.g., a Set)?#

Yes, you can. Instead of using Collectors.toList(), you can use Collectors.toSet() to collect the elements of the stream into a Set. For example:

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
 
public class ListToSetExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3);
        Set<Integer> numberSet = numbers.stream()
                .collect(Collectors.toSet());
        System.out.println(numberSet);
    }
}

Q2: Are lambda expressions and the Stream API thread-safe?#

The Stream API itself is not thread-safe. If you want to perform parallel operations on a stream for better performance, you need to ensure that the lambda expressions and the data being processed are thread-safe. You can use the parallelStream() method to create a parallel stream, but be cautious when sharing mutable state.

References#

In conclusion, Java 8's lambda expressions and Stream API offer a convenient and efficient way to convert lists, but developers must be aware of potential issues and follow best practices for optimal results.

2025-10