Expressão Lambda no Java 8

Em março de 2014 a Oracle Corporation lançou, de maneira oficial, o Java 8. Uma das principais novidades da nova versão foi, sem dúvida nenhuma, o suporte a expressão lambda, característica marcante nas linguagens de programação dinâmicas como Java Script, Groovy, Ruby, etc.

A expressão lambda é natural da programação funcional, porém outras linguagens de programação, de  paradigma não funcional, introduziram o recurso para possibilitar um código mais conciso, compacto e fácil de entender.

Falando especificamente do Java 8, uma expressão lambda é representada por uma interface funcional, ou seja, uma interface com um único método.

[sourcecode language=”java”]
public interface Comparable {
public int compareTo(Object o);
}
[/sourcecode]

Para entender melhor a aplicabilidade dessa nova funcionalidade do Java 8, criaremos um exemplo da execução das operações matemáticas soma e subtração. Inicialmente mostraremos a forma tradicional, sem o uso de expressão lambda. Em seguida, mudaremos o exemplo para usar expressão lambda e veremos a diferença entre as duas formas de implementação evidenciando a redução do código.

Primeiramente, definimos uma interface funcional chamada OperacaoMatematica.

[sourcecode language=”java”]
public interface OperacaoMatematica {
public int executar(int a, int b);
}
[/sourcecode]

Depois, implementamos as duas operações matemática de soma e subtração.

[sourcecode language=”java”]
public class Soma implements OperacaoMatematica {

@Override
public int executar(int a, int b)
return a + b;
}

}
[/sourcecode]

[sourcecode language=”java”]
public class Subtracao implements OperacaoMatematica {

@Override
public int executar(int a, int b)
return a – b;
}

}
[/sourcecode]

Criaremos a classe Teste e o método main para testar nossa interface funcional e suas implementações de soma e subtração.

[sourcecode language=”java”]
public class Teste {

public static int calcular(OperacaoMatematica om, int num1, int num2) {
return om.executar(num1, num2);
}

public static void main(String[] args) {
System.out.println("20 + 15 = " + calcular(new Soma(), 20, 15));
System.out.println("20 – 15 = " + calcular(new Subtracao(), 20, 15));
}

}
[/sourcecode]

Nosso exemplo ainda pode ser reduzido com o uso de classes anônimas, eliminando assim, nossas duas classes Soma e Subtracao.

[sourcecode language=”java”]
public static void main(String[] args) {
System.out.println("20 + 15 = " + new OperacaoMatematica() {
public int executar(int a, int b) {
return a + b;
}
});

System.out.println("20 – 15 = " + new OperacaoMatematica() {
public int executar(int a, int b) {
return a – b;
}
});
}
[/sourcecode]

Como podemos observar no nosso exemplo, eliminamos as classes Soma e Subtracao com o uso de classes anônimas, porém o código ficou muito mais confuso e complexo.
Com o recurso de expressão lambda, nosso código fica mais limpo, simples e compacto.
A operação soma será calculada pela expressão lambda: (a,b) -> a + b.
A operação subtração será calculada pela expressão lambda: (a,b) -> a – b.

[sourcecode language=”java”]
public class Teste {

public static int calcular(OperacaoMatematica om, int num1, int num2) {
return om.executar(num1, num2);
}

public static void main(String[] args) {
System.out.println("20 + 15 = " + calcular((a,b) -> a + b, 20, 15));
System.out.println("20 – 15 = " + calcular((a,b) -> a – b, 20, 15));
}

}
[/sourcecode]

Ainda podemos compactar mais nosso código eliminando a interface funcional OperacaoMatematica. Para isso, o Java 8 disponibiliza o pacote java.util.function que fornece várias interfaces funcionais para usar com expressões lambda e referência de métodos.
Concluindo nosso exemplo, vamos usar a interface funcional BiFunction que substitui nossa interface funcional OperacaoMatematica.

[sourcecode language=”java”]
public class Teste {

public static int calcular(BiFunction<Integer, Integer, Integer> bf, int num1, int num2) {
return bf.apply(num1, num2);
}

public static void main(String[] args) {
System.out.println("20 + 15 = " + calcular((a, b) -> a + b, 20, 15));
System.out.println("20 – 15 = " + calcular((a, b) -> a – b, 20, 15));
}

}
[/sourcecode]

Pronto pessoal, ficou nítido o ganho em compactação e clareza de código no nosso exemplo, e foi isso que busquei compartilhar com vocês.
A maioria das novidades do Java 8, como referência de métodos e implementação de métodos em interfaces, se concretizaram em detrimento do suporte à expressão lambda. Além disso, muitas APIs consagradas do Java, ganharam novos métodos para dar suporte a expressão lambda e serem invocados sob a forma de closure. Podemos citar, o método forEach na interface Iterable e o método stream na interface Collection, mas isso é assunto para outro post.

Até a próxima pessoal.