Artigos

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.

<br />
public interface Comparable {<br />
   public int compareTo(Object o);<br />
}<br />

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.

<br />
public interface OperacaoMatematica {<br />
	public int executar(int a, int b);<br />
}<br />

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

<br />
public class Soma implements OperacaoMatematica {</p>
<p>	@Override<br />
	public int executar(int a, int b)<br />
		return a + b;<br />
	}</p>
<p>}<br />

<br />
public class Subtracao implements OperacaoMatematica {</p>
<p>	@Override<br />
	public int executar(int a, int b)<br />
		return a - b;<br />
	}</p>
<p>}<br />

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

<br />
public class Teste {</p>
<p>	public static int calcular(OperacaoMatematica om, int num1, int num2) {<br />
		return om.executar(num1, num2);<br />
	}</p>
<p>	public static void main(String[] args) {<br />
		System.out.println(&quot;20 + 15 = &quot; + calcular(new Soma(), 20, 15));<br />
		System.out.println(&quot;20 - 15 = &quot; + calcular(new Subtracao(), 20, 15));<br />
	}</p>
<p>}<br />

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

<br />
public static void main(String[] args) {<br />
	System.out.println(&quot;20 + 15 = &quot; + new OperacaoMatematica() {<br />
		public int executar(int a, int b) {<br />
			return a + b;<br />
		}<br />
	});</p>
<p>	System.out.println(&quot;20 - 15 = &quot; + new OperacaoMatematica() {<br />
		public int executar(int a, int b) {<br />
			return a - b;<br />
		}<br />
	});<br />
}<br />

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.

<br />
public class Teste {</p>
<p>	public static int calcular(OperacaoMatematica om, int num1, int num2) {<br />
		return om.executar(num1, num2);<br />
	}</p>
<p>	public static void main(String[] args) {<br />
		System.out.println(&quot;20 + 15 = &quot; + calcular((a,b) -&gt; a + b, 20, 15));<br />
		System.out.println(&quot;20 - 15 = &quot; + calcular((a,b) -&gt; a - b, 20, 15));<br />
	}</p>
<p>}<br />

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.

<br />
public class Teste {</p>
<p>	public static int calcular(BiFunction&lt;Integer, Integer, Integer&gt; bf, int num1, int num2) {<br />
		return bf.apply(num1, num2);<br />
	}</p>
<p>	public static void main(String[] args) {<br />
		System.out.println(&quot;20 + 15 = &quot; + calcular((a, b) -&gt; a + b, 20, 15));<br />
		System.out.println(&quot;20 - 15 = &quot; + calcular((a, b) -&gt; a - b, 20, 15));<br />
	}</p>
<p>}<br />

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.

Um comentário

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

%d blogueiros gostam disto: