Lambda expressions in Java are inline functions used with functional interfaces to make code cleaner. Introduced in Java 8, they allow treating functionality as a method argument. They simplify tasks like sorting, filtering, and event handling. To use them, match the lambda to a functional interface’s method signature. Built-in interfaces like Predicate, Function, Consumer, Supplier, and UnaryOperator support common operations. Lambdas work best for short logic; complex logic should be extracted elsewhere. 1. Use lambdas to reduce boilerplate code. 2. Apply them mainly with collections and streams. 3. Ensure compatibility with functional interfaces. 4. Prefer built-in interfaces or define custom ones with one abstract method. 5. Keep lambda expressions concise for readability and maintainability.

Lambda expressions in Java might seem a bit confusing if you're used to writing code the traditional way, but once you get the hang of them, they can make your code cleaner and more expressive. They were introduced in Java 8, and since then, they’ve become a standard part of modern Java development.

Let’s break down what you really need to know about lambda expressions — not just syntax, but how and why you’d use them.

What are lambda expressions?

In simple terms, lambda expressions are a way to write inline functions without having to define a whole separate method or class. They’re especially useful when working with functional interfaces (interfaces that have only one abstract method), like Runnable, Comparator, or custom ones you create yourself.

For example, before Java 8, if you wanted to run some code in a new thread, you'd do something like:

new Thread(new Runnable() {
    public void run() {
        System.out.println("Old way");
    }
});

With lambdas, you can shorten that to:

new Thread(() -> System.out.println("New way")).start();

The key idea is:

• Lambdas let you treat functionality as a method argument
• You can pass behavior around like data
• It makes your code shorter and easier to read, especially with collections and streams

How to write a basic lambda expression

The general structure looks like this:

(parameters) -> { body }

Here are a few variations:

• No parameters:

  () -> System.out.println("No args")

• One parameter:

  x -> x * x

  (Parentheses are optional for single parameters)

• Multiple parameters:

  (a, b) -> a   b

What’s important is matching the lambda to the interface's method signature. For example, if you have a BiFunction<Integer, Integer, Integer>, the lambda should accept two integers and return an integer.

When to use lambda expressions

You’ll find yourself using lambdas most often in these situations:

• Sorting lists with custom logic:

  List<String> names = Arrays.asList("John", "Anna", "Mike");
  names.sort((a, b) -> a.compareTo(b));

• Filtering or processing data with streams:

  List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
  List<Integer> even = numbers.stream()
                               .filter(n -> n % 2 == 0)
                               .toList();

• Implementing event listeners or callbacks in GUI applications:

  button.addActionListener(e -> System.out.println("Button clicked"));

  Lambdas work best when the logic is short and self-contained. If it gets too long or complex, consider extracting it into a separate method or class.

  ---

  Functional interfaces are required

  You can’t use a lambda unless it matches a functional interface. That means the interface must have exactly one abstract method.

  Java provides several built-in functional interfaces in the java.util.function package:

  • Predicate<t></t> – takes one input, returns boolean
  • Function<t r></t> – takes one input, returns result
  • Consumer<t></t> – takes one input, doesn't return
  • Supplier<t></t> – no input, returns value
  • UnaryOperator<t></t> – takes one input, returns same type

  So when you write a lambda like x -> x > 10, it only works if the expected type is something like Predicate<integer></integer>.

  If you want to define your own functional interface, just make sure it has only one abstract method. Adding the @FunctionalInterface annotation is optional but helpful — it tells the compiler to check that you’re not accidentally adding extra methods.

  ---

  That’s the core of lambda expressions in Java. They’re not complicated once you understand how they match up with functional interfaces and where they fit naturally in your code. Keep using them in places like sorting, filtering, or event handling, and they’ll start to feel like second nature.

  Basically, that’s all you need to get started.

  The above is the detailed content of Java lambda expressions tutorial. For more information, please follow other related articles on the PHP Chinese website!