As expressões lambda, introduzidas no Java 8, representam um dos avanços mais significativos na linguagem desde sua criação.
Elas permitem que você trate funcionalidades como métodos de primeira classe ou expressões anônimas, facilitando a implementação de interfaces funcionais (interfaces com um único método abstrato).
O que é uma Expressão Lambda?
Uma expressão lambda é uma forma concisa de escrever implementações de interfaces funcionais. Elas permitem que você escreva métodos anônimos de maneira clara e concisa.
As expressões lambda ajudam a reduzir o código boilerplate, tornando o código mais legível e fácil de manter.
Sintaxe Básica
A sintaxe básica de uma expressão lambda é composta de três partes:
- Uma lista de parâmetros entre parênteses ().
- A seta de lambda ->.
- O corpo da expressão, que pode ser uma única expressão ou um bloco de código.
Sintaxe:
(parameters) -> expression
ou
(parameters) -> { statements; }Exemplos Simples de Lambda em Java
Abaixo, separamos 4 exemplos simples para ilustrar a sintaxe das expressões lambda em Java:
1. Lambda sem parâmetros:
() -> System.out.println("Hello, World!");2. Lambda com um parâmetro:
x -> x * x
3. Lambda com múltiplos parâmetros:
(x, y) -> x + y
4. Lambda com um bloco de código:
(x, y) -> {
int sum = x + y;
return sum;
}Exemplos de Uso do Lambda em Java
As expressões lambda são usadas em muitos contextos no Java, sendo os mais comuns:
Com a interface Runnable:
Runnable r = () -> System.out.println("Running in a separate thread");
new Thread(r).start();Com a interface Comparator:
Comparator<String> comparator = (s1, s2) -> s1.compareToIgnoreCase(s2);
List<String> list = Arrays.asList("a", "B", "c", "D");
Collections.sort(list, comparator);Com a API de Streams:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squares = numbers.stream()
.map(x -> x * x)
.collect(Collectors.toList());Agora vamos fazer um pouco diferente.
Uma classe vai demonstrar o uso básico de expressões lambda, e a outra vai focar na utilização da API de Streams.
Classe 1: Uso Básico de Expressões Lambda
package br.com.virandoprogramador.lambda
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class LambdaBasics {
public static void main(String[] args) {
// Exemplo 1: Uso com Runnable
Runnable runnable = () -> System.out.println("Executando em uma thread separada");
new Thread(runnable).start();
// Exemplo 2: Uso com Comparator
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave");
System.out.println("Lista original: " + names);
// Ordenar a lista sem distinção entre maiúsculas e minúsculas
Comparator<String> caseInsensitiveComparator = (s1, s2) -> s1.compareToIgnoreCase(s2);
Collections.sort(names, caseInsensitiveComparator);
System.out.println("Lista ordenada (case insensitive): " + names);
// Exemplo 3: Uso com uma interface funcional customizada
MyFunctionalInterface greeting = (name) -> System.out.println("Olá, " + name);
greeting.sayHello("Mundo");
// Exemplo 4: Passando comportamento como argumento
performOperation(5, x -> x * x); // Imprime: O resultado da operação é: 25
performOperation(7, x -> x + 10); // Imprime: O resultado da operação é: 17
}
@FunctionalInterface
interface MyFunctionalInterface {
void sayHello(String name);
}
public static void performOperation(int value, MyOperation operation) {
int result = operation.operate(value);
System.out.println("O resultado da operação é: " + result);
}
@FunctionalInterface
interface MyOperation {
int operate(int x);
}
}Classe 2: Uso de Expressões Lambda com API de Streams
package br.com.virandoprogramador.lambda
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
public class LambdaStreams {
public static void main(String[] args) {
List<String> strings = Arrays.asList("apple", "banana", "cherry", "date", "elderberry", "fig", "grape");
// Exemplo 1: Filtrar strings que começam com 'a' e coletar em uma lista
List<String> filteredStrings = strings.stream()
.filter(s -> s.startsWith("a"))
.collect(Collectors.toList());
System.out.println("Strings que começam com 'a': " + filteredStrings);
// Exemplo 2: Converter strings para maiúsculas e coletar em um set
Set<String> upperCaseStrings = strings.stream()
.map(String::toUpperCase)
.collect(Collectors.toSet());
System.out.println("Strings em maiúsculas: " + upperCaseStrings);
// Exemplo 3: Encontrar a string mais longa
Optional<String> longestString = strings.stream()
.reduce((s1, s2) -> s1.length() > s2.length() ? s1 : s2);
longestString.ifPresent(s -> System.out.println("A string mais longa é: " + s));
// Exemplo 4: Agrupar strings pelo seu comprimento
Map<Integer, List<String>> stringsByLength = strings.stream()
.collect(Collectors.groupingBy(String::length));
System.out.println("Strings agrupadas por comprimento: " + stringsByLength);
// Exemplo 5: Concatenar todas as strings com um delimitador
String concatenatedStrings = strings.stream()
.collect(Collectors.joining(", "));
System.out.println("Strings concatenadas: " + concatenatedStrings);
// Exemplo 6: Contar o número de strings que contêm a letra 'e'
long count = strings.stream()
.filter(s -> s.contains("e"))
.count();
System.out.println("Número de strings que contêm 'e': " + count);
}
}Finalizando sobre Lambda
As expressões lambda são uma poderosa adição à linguagem Java, oferecendo uma maneira mais concisa e legível de escrever código.
Elas facilitam a programação funcional, melhoram a integração com a API de Streams, aumentam a produtividade do desenvolvedor e aprimoram a concorrência e o paralelismo.
Além disso, permitem a implementação de callbacks e eventos de forma mais simples e oferecem maior flexibilidade e reutilização de código. Tudo isso, juntamente com a compatibilidade com código legado e o suporte a interfaces funcionais personalizadas, faz das expressões lambda uma ferramenta essencial para qualquer desenvolvedor Java moderno.
