Lambda expressions make the code more concise by simplifying the writing of anonymous internal classes. For example, use (p1, p2) -> p1.getName().compareTo(p2.getName()) to replace the anonymous class of Comparator, and can combine methods to reference such as Person::getName to improve readability; 2. The Stream API provides declarative data processing pipelines, such as filtering, map conversion, sorted sorting and collecting results, clearly expressing "what to do" rather than "how to do it", such as users.stream().filter(user -> user.getAge() > 25).map(User::getName).sorted().collect(Collectors.toList()); 3. Common pitfalls should be avoided when using it. It is recommended to call branch writing in chains, filter as soon as possible, avoid side effects, and use parallelStream with caution; 4. Logical reuse can be achieved by extracting Predicate and Function, such as Predicate isAdult = user -> user.getAge() >= 18, and condition combinations such as isAdult.and(user -> user.getAge()

Streams and Lambdas introduced in Java 8 have completely changed the way we process collection data. They not only make the code more concise, but also improve readability and maintenance. If you are still using traditional for loops to traverse collections, manually filter and transform data, it is time to upgrade your coding habits.

Let’s master these two powerful tools step by step and write cleaner and more expressive Java code.

1. Lambda expression: say goodbye to anonymous internal classes

Lambda is a block of code that can be passed, which makes functional programming possible in Java. The most common usage scenario is to replace interfaces with only one abstract method (i.e., functional interface).

For example: before sort vs after sort

 // Traditional way: use anonymous internal class Collections.sort(people, new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
});

//Collections.sort(people, (p1, p2) -> p1.getName().compareTo(p2.getName()));

Going further, you can also quote in combination with the method:

 people.sort(Comparator.comparing(Person::getName));

Commonly used functional interfaces:

• Predicate<T> : receives a parameter, returns boolean (for filtering)
• Function<T, R> : Receive a parameter and return the result (for conversion)
• Consumer<T> : receives a parameter with no return value (for performing an operation)
• Supplier<T> : No input, return a value (used to create an object)

Tips: Lambda can omit type declarations, brackets (for single arguments) and braces (for single statements), but do not oversimplify and cause readability to decrease.

2. Stream API: Process data in a declarative manner

Stream is not a data structure, but an operation pipeline . It is created from a collection or array, through intermediate operations (such as filter, map), and finally produces results by terminating operations (such as collect, forEach).

Basic structure:

 list.stream()
    .filter(condition)
    .map(transformation)
    .sorted()
    .collect(Collectors.toList());

Practical example: Find user names older than 25 and sort them alphabetically

 List<String> names = users.stream()
    .filter(user -> user.getAge() > 25)
    .map(User::getName)
    .sorted()
    .collect(Collectors.toList());

This code clearly expresses "what we want" rather than "how to do it step by step".

Common intermediate operations:

• filter(Predicate) : filter elements that meet the criteria
• map(Function) : Convert each element
• flatMap : expands each element in the stream into multiple elements (such as List Flattened)
• distinct() : Deduplicate
• limit(n) / skip(n) : pagination control

Common Termination Operations:

• collect() : Collect results (most commonly used)
• forEach() : traversal execution of operations
• count() : count
• anyMatch() / allMatch() / noneMatch() : determine whether there is an element that meets the condition

3. Avoid common pitfalls

Although Streams and Lambdas are powerful, they are also easy to misuse.

? It is recommended to do this:

• Chain calls should be clear : each operation takes up one line for easy debugging and reading.
• Filter as soon as possible : put filter in front to reduce the amount of data for subsequent operations.
• Avoid side effects : Do not modify external variables in Lambda, especially in concurrent environments.
• Be careful when using parallel streams : parallelStream() is not always faster and is only considered when the data volume is large and the operation is independent.

? Not recommended writing method:

 users.stream()
     .map(user -> {
         System.out.println(user); // Not recommended: do side effects in map return user.getName();
     })
     .forEach(System.out::println);

Should be changed to:

 users.stream()
     .map(User::getName)
     .forEach(System.out::println); // Or split logic

4. Practical skills: combination and reuse

You can extract the commonly used Predicate or Function and reuse it:

 Predicate<User> isAdult = user -> user.getAge() >= 18;
Function<User, String> toName = User::getName;

List<String> adults = users.stream()
    .filter(isAdult)
    .map(toName)
    .collect(Collectors.toList());

Even conditions can be combined:

 Predicate<User> isYoungAdult = isAdult.and(user -> user.getAge() < 30);

Basically that's it. The core idea of Streams and Lambdas is: express more intentions with less code . You may not be used to the functional style at the beginning, but once you master it, you will find that the logic of the previous dozens of lines can be solved in a few lines now, and it is safer and easier to test.

Not complicated, but it is easy to ignore details. Write more, read more, and refactor more, and you can also write "looks very advanced" Java code.

The above is the detailed content of Mastering Java 8 Streams and Lambdas for Cleaner Code. For more information, please follow other related articles on the PHP Chinese website!