The two core features of Java 8 are Lambda expressions and Stream API, which make the code more concise, readable and functional. 1. Lambda expressions are anonymous functions, used to simplify the implementation of functional interfaces, such as replacing the anonymous class of Comparator with (a, b) -> a.compareTo(b); 2. The Stream API provides a declarative data processing pipeline, supporting chain operations, such as filter, map, reduce, etc.; 3. Intermediate operations (such as filter, map) are lazy, and terminal operations (such as forEach, collect) trigger execution; 4. Common patterns include filtering mapping, flatMap flattening, reduce aggregation, and Collectors collection results; 5. Best practices include avoiding side effects, not reusing streams, and using parallelStream with caution; 6. Not suitable for simple loops or performance-sensitive scenarios. Mastering them can significantly improve the efficiency and code quality of collection processing, which is a necessary skill for modern Java development.

Java 8 introduced two game-changing features: Lambda expressions and the Stream API . Together, they revolutionized how developers write, read, and maintain Java code—especially when dealing with collections. This guide walks you through both concepts with practical examples, common patterns, and best practices.

What Are Lambda Expressions?

A lambda expression is a concise way to represent an anonymous function—a block of code that can be passed around and executed later. It's particularly useful for functional programming in Java.

Before Java 8, you'd often use anonymous inner classes:

 Collections.sort(names, new Comparator<String>() {
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

With lambdas, the same code becomes:

 Collections.sort(names, (a, b) -> a.compareTo(b));

Syntax of a Lambda

 (parameters) -> expression

Or for multiple statements:

 (parameters) -> { statements; }

Key Points:

• Lambdas work only with functional interfaces (interfaces with exactly one abstract method).
• Common functional interfaces in java.util.function include:
  • Predicate<T> : boolean test(T t)
  • Function<T, R> : R apply(T t)
  • Consumer<T> : void accept(T t)
  • Supplier<T> : T get()
  • UnaryOperator<T> , BinaryOperator<T>

Example Usage

 List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Predicate: filter names starting with "A"
Predicate<String> startsWithA = name -> name.startsWith("A");
names.stream()
     .filter(startsWithA)
     .forEach(System.out::println); // Output: Alice

Note: System.out::println is a method reference , shorthand for x -> System.out.println(x) .

Introduction to Streams

The Stream API allows you to process sequences of elements (like collections) in a declarative way—focusing on what to do, not how to do it.

Streams are not data structures. They don't store data, nor do they modify the source. Instead, they carry data through a pipeline of operations.

Creating a Stream

 // From a collection
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

// From an array
Stream<Integer> arrStream = Arrays.stream(new Integer[]{1, 2, 3});

// From values
Stream<String> valueStream = Stream.of("hello", "world");

// Infinite streams
Stream.iterate(0, n -> n 2).limit(5); // 0, 2, 4, 6, 8

Stream Operations: Intermediate vs Terminal

Streams support a chain of operations divided into two types:

1. Intermediate Operations (return a new Stream)

These are lazy —they don't execute until a terminal operation is called.

• filter(Predicate)
• map(Function)
• flatMap(Function)
• distinct()
• sorted()
• peek(Consumer)
• limit(n)
• skip(n)

2. Terminal Operations (trigger processing)

These consume the stream and produce a result or side effect.

• forEach(Consumer)
• collect(Collector)
• reduce(BinaryOperator)
• count()
• anyMatch(Predicate)
• findFirst()
• toArray()

Example Pipeline

 List<String> result = names.stream()
    .filter(name -> name.length() > 4)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

This reads naturally: “Filter long names, convert to uppercase, sort, and collect.”

Common Stream Patterns

Filtering and Mapping

 List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6);

List<Integer> evenSquares = nums.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * n)
    .collect(Collectors.toList()); // [4, 16, 36]

FlatMap for Nested Structures

Use flatMap to flatten streams of streams.

 List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d")
);

List<String> all = listOfLists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList()); // ["a", "b", "c", "d"]

Reduction with reduce()

 Optional<Integer> sum = nums.stream()
    .reduce((a, b) -> ab); // Optional[21]

Or with identity:

 int total = nums.stream().reduce(0, Integer::sum); // 21

Collecting Results

Collectors is your go-to utility for gathering stream output.

 // To List
List<String> list = stream.collect(Collectors.toList());

// To Set
Set<String> set = stream.collect(Collectors.toSet());

// To String with joining
String joined = stream.collect(Collectors.joining(", "));

// Grouping by a property
Map<Integer, List<String>> byLength = names.stream()
    .collect(Collectors.groupingBy(String::length));

Example:

 // Group names by length
{
    3: ["Bob"],
    5: ["Alice"],
    7: ["Charlie"]
}

Partitioning

Split based on a predict:

 Map<Boolean, List<String>> partitioned = names.stream()
    .collect(Collectors.partitioningBy(s -> s.startsWith("A")));
// true: [Alice], false: [Bob, Charlie]

Performance and Best Practices

• Streams are lazy : Intermediate operations don't run until terminal operation is invoked.
• Avoid side effects in lambdas. They should be stateless.
• Prefer streams for readability, but don't overuse them for simple loops.
• Use parallelStream() with caution—only when data is large and operations are independent.
• Don't reuse streams: A stream can be consumed only once.

 Stream<String> s = list.stream();
s.forEach(System.out::println); // OK
s.forEach(System.out::println); // IllegalStateException!

When Not to Use Streams

• Simple loops with side effects (eg, updating external variables).
• Performance-critical loops where overhead matters.
• When code becomes less readable (eg, deeply nested flatMaps).

Sometimes a plain for loop is clearer.

Summary

Java 8's lambdas and streams make code more expressive and functional. You can:

• Replace verbose anonymous classes with clean lambda syntax.
• Chain operations on data using streams.
• Use built-in collectors for grouping, joining, and reducing.
• Write declarative, readable code.

They don't replace traditional loops entirely, but they're powerful tools when used appropriately.

Basically, if you're working with collections in Java, learning streams and lambdas is essential—and once you get used to them, you'll wonder how you lived without.

The above is the detailed content of A Comprehensive Guide to Java 8 Streams and Lambdas. For more information, please follow other related articles on the PHP Chinese website!