Uma das grandes novidades do Java 8 foi a inclusão das expressões lambda, cujo propósito é permitir a definição métodos anônimos diretamente no local de sua utilização. Um método ou função-membro anônimo sintetiza uma funcionalidade que será utilizada uma única vez, de modo a evitarmos o uso de classes anônimas. De fato, o uso de expressões lambda torna possível a passagem de código para métodos ao invés de objetos.
A origem das expressões lambda é o cálculo lambda ou cálculo-λ que foi proposto por Alonzo Church na década de 1930. O cálculo-λ é uma notação matemática formal composta das expressões lambda e de um conjunto sofisticado de regras de aplicação que permitem descrever e avaliar funções anônimas, recursivas e computáveis as quais podem ser usadas tanto como argumentos ou como valor de retorno de outras funções.
Sintaxe das expressões lambda
Uma expressão lambda é, em essência, uma função anônima, isto é, um método sem nome, sem especificadores de acesso e sem modificadores, onde também se omite o tipo do valor de retorno e, quando possível, o tipo de seus parâmetros. Assim, privilegia-se sua funcionalidade (seu código) e simplifica-se a lista necessária de parâmetros.
Uma expressão lambda pura em Java consiste numa lista de parâmetros enviada diretamente para uma expressão, cujo resultado é retornado implicitamente, ou seja:
(listaParâmetros) -> expressão
Exemplos de expressões lambda puras são:
- (x) -> 2*x + 1
- (x,y) -> 3*x >= 2*y
- (p,m,h) -> 1.5*p + 1.9*m + 2.0*h
A primeira expressão lambda pode ser lida como: a função que, dado o parâmetro de entrada x, retorna o resultado da expressão 2*x + 1. Então o novo operador lambda -> pode ser lido como “que retorna” ou “que produz”. A segunda expressão lambda é, portanto, a função que dado os parâmetros de entrada x e y produz o resultado da expressão 3*x >= 2*y. Outra forma de leitura, da última expressão lambda por exemplo, seria os parâmetros p, m e h enviados a expressão 1.5*p + 1.9*m + 2.0*h retornando seu resultado.
Nestas expressões lambda podem ser observadas as seguintes características voltadas para sua simplicidade:
- Os parêntesis iniciais são requeridos para delimitar a lista de parâmetros da expressão lambda. Podem ser omitidos apenas quando existe somente um parâmetro.
- Os tipos dos parâmetros podem ser omitidos, pois em geral são inferidos pelos compilador, a partir do contexto de uso da expressão lambda. Quando a inferência de tipos não é possível, devem ser indicados como na declaração de métodos.
- Quando a expressão lambda é pura, não é necessário o uso explícito da diretiva return.
As expressões lambda também podem ser mais sofisticadas que uma expressão, envolvendo assim blocos de código que podem conter declarações de variáveis, diretivas Java e a combinação de diversas expressões, incluindo instanciação de objeto e sua utilização. Neste caso a sintaxe requer o uso de chaves para delimitar o bloco de código da expressão lambda como segue:
(listaParâmetros) -> { blocoDeCódigo }
Um exemplo de expressão lambda dotada de bloco de código é:
(double[] array, int sp, int ep) -> {
double total = 0;
for(int i=sp; i<ep; i++) total =+ array[i];
return total;
}
Aqui foram indicados os tipos dos parâmetros, o que pode ser necessário quando o compilador não é capaz de determinar seus tipos dentro do contexto de uso da expressão lambda. Além disso, como esta expressão lambda emprega um bloco de código, o uso explícito da diretiva return, para indicar seu resultado, é obrigatório.
Tipo-Alvo (target-type) das expressões lambda
É comum descrever métodos por meio de sua assinatura, isto é, a combinação das informações relativas ao seu tipo de retorno, seu nome e a lista dos tipos de seus parâmetros entre parêntesis. Por exemplo, o método Math.pow tem assinatura double pow(double, double), ou seja, toma dois parâmetros do tipo double e retorna um valor double; enquanto o método length da classe String tem assinatura int length(void), pois não toma parâmetros e retorna um valor int.
Já as expressões lambda são descritas por seu target-type ou tipo-alvo, de maneira semelhante aos métodos: o tipo de retorno seguido da lista dos tipos de seus parâmetros entre parêntesis. Então a expressão lambda (x) -> 2*x + 1 pode possuir um target-type int (int), ou seja, recebe um parâmetro int, retornando resultado do mesmo tipo, embora possa ser double (double), dependendo do contexto de sua utilização no programa, mais diretamente de como o parâmetro x foi declarado antes da expressão lambda.
Outros exemplos de tipos-alvo de expressões lambda são:
- boolean (double, double) para (x,y) -> 3*x >= 2*y;
- double (double, double, double) para(p,m,h) -> 1.5*p + 1.9*m + 2.0*h;
- int (int, int) para (a, b) -> a > b ? a : b;
- float (String) para (s) -> Float.parseFloat(s.substring(1)); e
- double (void) para ( ) -> Math.PI/2.
É importante conhecer os tipo-alvo das expressões lambda por duas razões: para determinar onde podem ser empregada e para orientar a construção de expressões compatíveis com necessidades específicas.
Para que seja possível aplicar as expressões lambda é preciso conhecer as interfaces funcionais e como são tradicionalmente usadas, isto é, sua forma de aplicação típica antes do Java 8.
Interfaces funcionais
Interfaces funcionais são aquelas que possuem um único método abstrato em suas declarações. Antes do Java 8 as interfaces funcionais já existiam, mas eram conhecidas como single abstract methods (SAM) interfaces. Esta nova denominação acompanha a introdução das expressões lambda que são construções típicas do paradigma de programação funcional.
Uma interface funcional pode ser como Filter, que segue.
/* Arquivo: Filter.java
*/
package jandl.j8l;
@FunctionalInterface
public interface Filter {
boolean accept(Student s);
}
A anotação @FuntionalInterface possibilita que o compilador verifique se existe apenas um método abstrato na interface, como exigido pelas interfaces funcionais. Outros métodos default e estáticos podem existir, bem como campos. No caso, o único método existente, de assinatura boolean accept(Student), define uma operação de validação sobre o objeto Student recebido como parâmetro, retornando true quando aceito, isto é, quando atende uma condição específica, e false quando rejeitado. A realização da interface Filter requer, portanto, a implementação do método accept para a aplicação do critério desejado.
A classe Student utilizada na interface Filter representa um estudante por meio de suas informações de registro acadêmico (sId), nome e curso. Uma implementação bastante simples poderia ser como segue. Nela observam-se os campos necessários para armazenar as informações do estudante, um construtor parametrizado, os métodos de observação (accessors) get, os métodos correspondentes de alteração (mutators) set; e o método toString para obtenção de uma representação textual do objeto.
/* Arquivo: Student.java
*/
package jandl.j8l;
public class Student {
// campos para atributos do tipo
private long sId;
private String name;
private int course;
// construtor
public Student(long sId, String name, int course) {
this.sId = sId;
this.name = name;
this.course = course;
}
// métodos getter públicos
public long getSID() { return sId; }
public String getName() { return name; }
public int getCourse() { return course; }
// métodos setter protegidos
protected void setSID(long sId) {
this.sId = sId; }
this.sId = sId; }
protected void setName(String name) {
this.name = name; }
this.name = name; }
protected void setCourse(int course) {
this.course = course; }
this.course = course; }
// representação textual
@Override
public String toString() {
return String.format("[%07d|%03d] %s", sId, course, name);
}
}
Para simplificar este exemplo, a classe StudentDB representa um banco de dados de estudantes, na verdade um ArrayList de objetos do tipo Student, estaticamente instanciado e acrescido de um pequeno conjunto de objetos adequados, acessível por meio da variável estática db. O método estático ArrayList<Student> subList(Filter) retorna um subconjunto dos alunos do banco de dados que atendem ao critério determinado pelo objeto Filter recebido como parâmetro.
/* Arquivo: StudentDB.java
*/
package jandl.j8l;
import java.util.ArrayList;
public class StudentDB {
// campo estático db arraylist que simula banco de dados
public static ArrayList<Student> db = new ArrayList<>();
// bloco estático para inicialização do campo estático db
static {
db.add(new Student(1200001, "Bernardo Silva", 18));
db.add(new Student(1200015, "Alice Pedrosa Souza", 18));
db.add(new Student(1200348, "Miguel Costa", 18));
db.add(new Student(1300001, "Arthur Santos", 18));
db.add(new Student(1300001, "Julia Oliveira", 116));
db.add(new Student(1310009, "Henrique Pereira", 18));
db.add(new Student(1310624, "Murilo Almeida", 18));
db.add(new Student(1400045, "Gabriel Rodrigues", 116));
db.add(new Student(1400101, "Sofia Nascimento", 18));
db.add(new Student(1400632, "Enzo Lima", 116));
db.add(new Student(1411234, "Davi Araújo", 18));
}
public static ArrayList<Studant> subList(Filter filter) {
// cria sublista
ArrayList<Student> result = new ArrayList<>();
// percorre todo banco de dados
for(Student s: db) {
// aplica filtro: se critério aceito,
// adiciona na sublista
// adiciona na sublista
if (filter.accept(s)) result.add(s);
}
// retorna sublista
return result;
}
}
Aplicação das interfaces funcionais
Uma implementação da interface Filter, para criação de um filtro específico para objetos do tipo Student, pode ser como a classe CourseFilterImpl, cujo método accept verifica se o estudante recebido como argumento está matriculado num curso específico.
/* Arquivo: CourseFilterImpl.java
*/
package jandl.j8l;
public class CourseFilterImpl implements Filter {
@Override
public boolean accept(Student s) {
// aceita estudantes do curso 18
return s.getCourse()==18;
}
}
Neste ponto contamos com:
- uma interface funcional Filter que especifica uma operação de validação de objetos Student;
- a classe Student que representa um estudante;
- a classe StudentDB que constitui um banco de dados simulado de estudantes, dispondo de uma operação de filtragem denominada subList(Filter); e
- uma implementação da interface funcional Filter, denominada CourseFilterImpl, que filtra alunos de um curso específico.
Com estes elementos é possível construir um programa para testar a implementação CourseFilterImpl da interface funcional Filter para obtenção de um subconjunto de alunos específicos do banco de dados. Na classe Teste01 que segue existem três trechos de código. No primeiro são exibidos os estudantes existentes no banco de dados e também declarada uma lista do tipo ArrayList<Student> que será usada nos demais trechos.
No segundo trecho é acionado o método subList(Filter) da classe StudentDB com uso de uma instância da classe CourseFilterImpl. Com isso é retornado um ArrayList<Student> que corresponde ao subconjunto dos estudantes matriculados no curso 18, conforme indicado na classe CourseFilterImpl. A lista retornada é exibida, o que permite verificar se a filtragem ocorreu corretamente.
No último trecho o método subList(Filter) é novamente acionado, mas agora com uso de uma instância de uma classe anônima que realiza a interface Filter. Desta maneira é retornado um outro ArrayList<Student> contendo o subconjunto dos estudantes ingressantes a partir de 2014 (isto é de RA maior que 1400000). A lista retornada também é exibida para possibilitar a conferência da filtragem realizada.
/* Arquivo: Teste01.java
*/
import jandl.j8l.CourseFilterImpl;
import jandl.j8l.Filter;
import jandl.j8l.Student;
import jandl.j8l.StudentDB;
import java.util.ArrayList;
public class Teste01 {
public static void main(String[] args) {
// exibe DB de estudantes
System.out.println("Todos:");
System.out.println(StudentDB.db.toString());
// sublista de estudantes
ArrayList<Student> lista;
// obtém sublista de estudantes do curso 18,
// filtro implementado como classe independente
lista = StudentDB.subList(new CourseFilterImpl());
// exibe sublista
System.out.println("Curso 18:");
System.out.println(lista.toString());
// obtém sublista de estudantes que
// ingressaram de 2014 em diante,
// ingressaram de 2014 em diante,
// filtro implementado como classe independente
lista = StudentDB.subList(new Filter () {
@Override
public boolean accept(Student s) {
return s.getSID()>1400000;
}
});
// exibe sublista
System.out.println("RA>1400000:");
System.out.println(lista.toString());
}
}
Os resultados da classe Teste01 são como abaixo.
Todos:
[[1200001|018] Bernardo Silva, [1200015|018] Alice Pedrosa Souza, [1200348|018] Miguel Costa, [1300001|018] Arthur Santos, [1300001|116] Julia Oliveira, [1310009|018] Henrique Pereira, [1310624|018] Murilo Almeida, [1400045|116] Gabriel Rodrigues, [1400101|018] Sofia Nascimento, [1400632|116] Enzo Lima, [1411234|018] Davi Araújo]
Curso 18:
[[1200001|018] Bernardo Silva, [1200015|018] Alice Pedrosa Souza, [1200348|018] Miguel Costa, [1300001|018] Arthur Santos, [1310009|018] Henrique Pereira, [1310624|018] Murilo Almeida, [1400101|018] Sofia Nascimento, [1411234|018] Davi Araújo]
RA>1400000:
[[1400045|116] Gabriel Rodrigues, [1400101|018] Sofia Nascimento, [1400632|116] Enzo Lima, [1411234|018] Davi Araújo]
Apesar do programa ter funcionado como esperado, devemos considerar algumas questões:
- O método subList(Filter) é bastante conveniente, pois por meio de filtros diferentes, é possível a obtenção de subconjuntos distintos do conjunto integral de dados.
- A implementação de uma classe específica para realização, apesar de tornar simples o uso do método subList(Filter), pode exigir a construção de várias classes simples, com código repetitivo. Além disso, a fragmentação do código, neste caso, não contribui para o entendimento da solução, pois o critério da filtragem fica contido na classe que realiza a interface do filtro.
- O emprego de uma classe anônima reduz a fragmentação do código, permite que o critério de filtragem seja mais explícito. No entanto, a implementação em si da classe anônima acrescenta complexidade desnecessária ao código.
É exatamente por causa deste tipo de problema que as expressões lambda foram introduzidas no Java 8!
Aplicações das expressões lambda
O objetivo das expressões lambda, ou simplesmente lambdas, é permitir a definição simplificada de funções anônimas no local onde serão utilizadas. Com isso, os lambdas constituem meio para que o programador passe funcionalidades ao invés de objetos, o que pode ser tanto utilizado na passagem de parâmetros, como no retorno de valores. Assim, os lambdas são um mecanismo poderoso e ao mesmo tempo simples.
Observe a classe Teste02 que segue, que tem a mesma estrutura da classe Teste01 e realiza, exatamente, as mesmas operações. As alterações se encontram no segundo e terceiro trechos onde as expressões lambda destacadas substituíram tanto a instância de CouserFilterIML quanto a classe anônima que realiza a interface funcional Filter.
/* Arquivo: Teste02.java
*/
import jandl.j8l.Student;
import jandl.j8l.StudentDB;
import java.util.ArrayList;
public class Teste02 {
public static void main(String[] args) {
// exibe DB de estudantes
System.out.println("Todos:");
System.out.println(StudentDB.db.toString());
// sublista de estudantes
ArrayList<Student> lista;
// obtém sublista de estudantes do curso 18,
// filtro implementado como classe independente
lista = StudentDB.subList(s -> s.getCourse() == 18);
// exibe sublista
System.out.println("Curso 18:");
System.out.println(lista.toString());
// obtém sublista de estudantes que
// ingressaram de 2014 em diante,
// ingressaram de 2014 em diante,
// filtro implementado como classe independente
lista = StudentDB.subList(s -> s.getSID()>1400000);
// exibe sublista
System.out.println("RA>1400000:");
System.out.println(lista.toString());
}
}
No segundo trecho, a instância de CourseFilterImpl que segue:
É substituída por esta expressão lambda:
s -> s.getCourse() == 18
public class CourseFilterImpl implements Filter {
@Override
public boolean accept(Student s) {
return s.getCourse()==18;
return s.getCourse()==18;
}
}
É substituída por esta expressão lambda:
s -> s.getCourse() == 18
No terceiro trecho, a instância de uma classe anônima que realiza Filter destacada:
É substituída por outra expressão lambda:
s -> s.getSID()>1400000
new Filter () {
@Override
public boolean accept(Student s) {
return s.getSID()>1400000;
}
}
É substituída por outra expressão lambda:
s -> s.getSID()>1400000
Nos dois casos as expressões lambda substituíram convenientemente as alternativas anteriores, reduzindo a quantidade de código necessária e, mais importante, mantendo a clareza do código, pois a operação desejada torna-se explícita.
Existem inúmeras possibilidades de uso das expressões lambda, dentre elas a criação simplificada de threads, event listeners do tipo ActionListener, objetos Comparator<T> e Comparable. Por exemplo, a criação e registro de um ActionListener, usualmente necessária na construção de interfaces GUI é como:
Pode ser feito como segue:
JButton button = new JButton("Incrementar");
button.addActionListener(new ActionListener () {
@Override
public void actionListener(ActionEvent e) {
// incr. variável valor, declarada no escopo
valor++;
// imprime valor no console
System.out.println("Valor:" + valor);
}
});
Pode ser feito como segue:
JButton button = new JButton("Incrementar");
button.addActionListener( (e) -> {
// incr. variável valor, declarada no escopo
valor++;
// imprime valor no console
System.out.println("Valor:" + valor);
});
Considerações finais
Do ponto de vista de programação uma expressão lambda, cujo target-type é compatível com o único método abstrato de uma interface funcional, pode substitui um objeto que implementa tal interface, com a vantagem da maior simplicidade e clareza. Já do ponto de vista de geração de código, um lambda é sempre substituído por uma instância de uma classe anônima equivalente gerada pelo compilador.
Além disso, as expressões lambda têm acesso às variáveis presentes no contexto de sua utilização, podendo utiliza-las em seu código, um mecanismo denominado captura de variáveis. Mesmo que tais variáveis sejam alteradas dentro do código do lambda não ocorrem efeitos colaterais, isto é, as alterações não são propagadas para o escopo externo ao lambda, tornando ainda mais conveniente a utilização desta alternativa de programação.
Para facilitar o uso das expressões lambda no Java 8 foi introduzido o pacote java.util.function, o qual disponibiliza um bom conjunto de interfaces funcionais de propósito geral pré-definidas, muitas das quais são definidas por meio dos genéricos, tornando ainda mais flexível sua utilização.
Referências
- Java - Guia do Programador. 3a Edição. [visualizar]Peter Jandl Junior.Novatec. 2015.
- Lambda Expressions (The Java Tutorials).
- When to Use Nested Classes, Local Classes, Anonymous Classes, and Lambda Expressions (The Java Tutorials).
- Lambda Expressions in Java 8.
Este artigo faz parte de uma pequena série:
