To write concise and customary Java 8 code, you must use modern language features reasonably and follow the principles of readability and maintainability. 1. Use lambda expressions and method references to replace anonymous internal classes, such as using people.sort(Comparator.comparing(Person::getName)) instead of traditional Comparator, and when lambda only calls a single method, use System.out::println and other methods to reference; 2. Use Stream API in data conversion, such as building processing chains through users.stream().filter(User::isActive).map(User::getEmail).collect(Collectors.toList()) but avoid excessive chain calls. When complex, methods should be split or extracted, and nested structures should be flattened with flatMap; 3. Use Optional correctly, only as a return type to express possible missing values, avoid using fields, parameters or collection elements, do not abuse get(), and give priority to using ifPresent, orElseGet and other security methods; 4. Make priority to design immutable objects, make good use of record (Java 14) to simplify data carriers, such as public record Person(String name, int age) {}, and use var carefully, simplify declarations only when the type is clear, such as var list = new ArrayList() to avoid type blurring; 5. Handle exceptions elegantly in functional contexts, and wrap the detected exceptions by encapsulating the unchecked function, or explicitly handle them in lambda instead of throwing a broken streaming operation; 6. Use LocalDateTime, ZonedDateTime, Duration and other types in the java.time package to replace outdated Date and Calendar, and use DateTimeFormatter for parsing and formatting; 7. Always aim for clarity, not to use new features for showing off skills, keeping the code as easy to read as prose, truly reflecting the modern programming style of Java 8.

Writing clean and idiomatic Java 8 code means embracing the language features introduced from Java 8 onward—like lambdas, streams, Optional , method references, and the new date/time API—while adhering to principles of readability, simplicity, and maintainability. Here's how to write Java code that feels modern, expressive, and true to the spirit of the platform.

Use Lambdas and Method References Where Appropriate

Lambdas make code more concise when working with functional interfaces. Replace anonymous inner classes with lambdas, especially in event handlers, Runnable s, or Comparator s.

Avoid:

 Collections.sort(people, new Comparator<Person>() {
    @Override
    public int compare(Person a, Person b) {
        return a.getName().compareTo(b.getName());
    }
});

Prefer:

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

Use method references ( :: ) when the lambda body is just a single method call. They're more readable and often more efficient.

 // Instead of
list.forEach(s -> System.out.println(s));

// Use
list.forEach(System.out::println);

Tip: Don't overuse lambdas. If the logic becomes complex (eg, multiple lines, conditions, mutations), extract it into a well-named method and use a method reference.

Embrace Streams for Data Transformations

Streams help express data processing pipelines clearly. Use them when filtering, mapping, or reducing collections.

Example:

 List<String> emails = users.stream()
    .filter(User::isActive)
    .map(User::getEmail)
    .filter(email -> email.endsWith("@company.com"))
    .collect(Collectors.toList());

Best practices:

• Avoid overly long stream chains. Break them with intermediate variables or extract to methods if they become hard to read.
• Prefer Stream over manual loops for transformations, but don't force it. Simple iterations? A for-each loop is fine.
• Use flatMap to flatten nested structures:

   List<String> allWords = sentences.stream()
      .flatMap(s -> Arrays.stream(s.split(" ")))
      .toList();

Note: Streams are not always faster. Use them for clarity, not performance assumptions.

Use Optional Correctly

Optional is designed to be a return type, not a field or parameter. It helps avoid null and forces callers to handle absence explicitly.

Good:

 public Optional<User> findUserById(String id) {
    return users.stream()
        .filter(u -> u.getId().equals(id))
        .findFirst();
}

Don't do this:

 Optional<User> user = Optional.ofNullable(findUser());
user.ifPresent(u -> System.out.println(u.getName()));

That's redundant. Just use:

 Optional<User> userOpt = findUserById("123");
userOpt.ifPresent(System.out::println);

Avoid:

• Calling get() without checking isPresent() (defeats the purpose).
• Using Optional in fields, parameters, or as elements in collections.
• Overusing orElse(new ArrayList<>()) — prefer orElseGet(ArrayList::new) to avoid unnecessary object creation.

Prefer Immutable Objects and var Judiciously

Immutability reduces bugs. Use final fields and consider records (Java 14 ) for data carriers.

 public record Person(String name, int age) {}

Use var to reduce verbosity when the type is obvious:

 var list = new ArrayList<String>(); // OK
var total = calculateTotal(); // Avoid — type isn&#39;t clear

Rule of thumb: Only use var when the right-hand side makes the type obvious. Don't sacrifice readability for brevity.

Handle Exceptions Gracefully

Java 8 doesn't eliminated checked exceptions, but you can work around them cleanly in streams.

Example: Wrapping checked exceptions:

 public static <T> Consumer<T> unchecked(ThrowingConsumer<T> consumer) {
    return t -> {
        try {
            consumer.accept(t);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}

// Usage
list.forEach(unchecked(file -> Files.write(Paths.get(file), data)));

Alternatively, handle exceptions explicitly inside the lambda instead of polluting functional code with try-catch .

Use the Modern Date/Time API (java.time)

Forget Date and Calendar . Use LocalDateTime , ZonedDateTime , Duration , etc.

 LocalDateTime now = LocalDateTime.now();
LocalDateTime tomorrow = now.plusDays(1);

Duration duration = Duration.between(start, end);

Parse and format with DateTimeFormatter :

 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate date = LocalDate.parse("2023-10-01", formatter);

Final Thoughts

Writing clean, idiomatic Java 8 code isn't just about using new features—it's about using them purposefully . The goal is clarity, not cleverness.

Key takeaways:

• Prefer streams and lambdas for data processing, but keep them readable.
• Use Optional to express optional returns—not as a crutch.
• Embrace immutability and records.
• Format dates with java.time .
• Use var wisely.
• Handle exceptions without breaking functional flow.

Clean code reads like prose. Let Java 8 help you write it.

The above is the detailed content of Writing Clean and Idiomatic Java 8 Code. For more information, please follow other related articles on the PHP Chinese website!