Wat zijn lambda-uitdrukkingen in Java en welke…

Lambdafuncties in Java zijn een korte syntax voor het maken van anonieme functies (methoden zonder naam) die als argumenten kunnen worden doorgegeven of in variabelen kunnen worden opgeslagen. In wezen zijn het functionele interfaces die "op het moment" worden geïmplementeerd.

De belangrijkste mogelijkheden die lambda-uitdrukkingen bieden:

Vereenvoudiging van syntax: Ze verkorten de boilerplate-code aanzienlijk bij het werken met functionele interfaces in vergelijking met anonieme interne klassen.

// Voor lambda:
Runnable classicRunnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Klassieke Runnable");
    }
};

// Met lambda:
Runnable lambdaRunnable = () -> System.out.println("Lambda Runnable");

Functioneel programmeren: Ze maken het mogelijk om meer functionele code te schrijven, waarbij functies first-class burgers zijn en als gegevens kunnen worden doorgegeven. Dit is essentieel voor het werken met de Stream API.

// Filteren van een lijst met lambda
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> filteredNames = names.stream()
                                 .filter(name -> name.startsWith("A"))
                                 .collect(Collectors.toList());

Werken met de Stream API: Lambda-uitdrukkingen vormen de basis voor de meeste operaties in de Stream API (filter, map, forEach, reduce, etc.), waardoor beknoptheid en parallelle uitvoering mogelijk zijn.

// Transformatie en output van stream-elementen
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
       .map(n -> n * n) // lambda voor mapping
       .forEach(System.out::println); // methode-referentie (alternatief voor lambda)

Verbeterde leesbaarheid: Voor eenvoudige operaties maken lambdas de code leesbaarder en begrijpelijker, doordat de focus op de operatie zelf ligt en niet op de syntax van de anonieme klasse.
Implementatie van functionele interfaces: Ze kunnen overal worden gebruikt waar een instantie van een functioneel interface wordt verwacht (interface met één abstracte methode).

Syntax van de lambda-uitdrukking: (parameters) -> { lichaam }

Voorbeelden:

Zonder parameters, zonder returnwaarde: () -> System.out.println("Hallo")
Met één parameter, zonder returnwaarde: name -> System.out.println("Hallo, " + name) (haakjes rond één parameter kunnen worden weggelaten)
Met meerdere parameters, zonder returnwaarde: (x, y) -> System.out.println(x + y)
Met parameters, met returnwaarde: (a, b) -> a + b (als de body uit één uitdrukking bestaat, wordt de waarde impliciet geretourneerd)
Met parameters, met codeblok en returnwaarde: (a, b) -> { int sum = a + b; return sum; } (expliciete return is vereist voor codeblokken)

Wat zijn lambda-uitdrukkingen in Java en welke mogelijkheden bieden ze?