Lambdas

Retornar

Lambdas

• Lambda vem da Programação Funcional

• Conceito adicionado no Java8

• A grande vantagem de funções lambda é diminuir a quantidade de código necessária para escrever alguma função

• Uma função lambda é uma função sem declaração(não é necessário um nome, tipo de retorno e o modificador de acesso)

• A idéia é que o método seja declarado no mesmo lugar em que será usado

• As funções lambdas em Java tem a sintaxe definica como:

  • (argumento) -> (corpo)

• Existem tipos de Expressões Lambdas:

Tipo	Descrição
Function	Recebe um parâmetro e produz um resultado qualquer
Predicate	Recebe um parâmetro e produz um booleano
BinaryOperator	Recebe dois parâmetros do mesmo tipo e produz um resultado do mesmo tipo
Consumer	Recebe um parâmetro e não produz resultado
Supplier	Não recebe parâmetros e produz um resultado

• Exemplo de Expressão Lambda Simples:

 (int a,int b) -> a + b; //TIPO DE EXPRESSÃO LAMBDA: BinaryOperator
 
 () -> new Object() // TIPO DE EXPRESSÃO LAMBDA: Supplier

 
(String s) -> {System.out.println(s);} //TIPO DE EXPRESSÃO LAMBDA: Consumer

(int x) -> x++; //TIPO DE EXPRESSÃO LAMBDA: Function

(double x, double y) -> x+y; //TIPO DE EXPRESSÃO LAMBDA: BinaryOperator

• Uma função Lambda pode ter nenhum ou vários parâmetros
• A função lambda pode ter nenhum ou vários comandos
• Se tiver somente um comando, as chaves não são obrigatórias
• Se nada for retornado a função retorna um void
• Uma expressão Lambda resulta em um elemento manipulável

Threads

• Threads são utilizadas para simplificar o código

• Cada processo possui diversas threads(linhas de instruções)

• Podemos dividir partes do nosso processo(Programa Java) para trabalhar paralelamente

• Se voçê deseja que o programa não "trave o usuário" naquele determinado procedimento que pode demorar, Use threads

• Como se usa:

  • Primeiro é criada uma implementação do método run da interface Runnable
  • Segundo é criada a Thread com essa implementação.
  • Com a expressão lambda, o código necessário para a implementação é bastante simples e menor
  • Ex:

Runnable r = () -> System.out.println("Thread com função Lambda!");
new Thread(r).start();

• Essa expressão não passa nenhum parâmetro, pois ela será passada para a função run
• Pode-se fazer também é passar a função diretamente como parâmetro para o construtor da classe Thread
• Funções lambdas podem ser definidas e passadas como parâmetros diretamente para outros métodos

new Thread(() -> System.out.println("Hello World")).start();

Funções lambdas com Collections

• Lambdas podem ser bastantes utilizadas com as classes de Coleções Java
• Pode-se percorrer a coleção, fazer uma ação, filtrar elementos, etc...
• Exemplo de como percorrer uma lista e imprimir os valores
• Foi usado um ForEach para percorrer a lista

List<Integer> lista = Arrays.asList(1,2,3,4,5,6,7);
for(Integer n : lista){
    System.out.println(n);
}

• Com as funções lambdas é possivel implementar a mesma funcionalidade com menos código
• Basta chamar o método forEach de uma lista, que é um método que espera uma função lambda como parâmetro
• Exemplo de uma impressão de elementos de uma lista com Lambda

List<Integer> lista = Arrays.asList(1,2,3,4,5,6,7);
lista.forEach(n -> System.out.println(n));

• Dentro de uma expressão Lambda qualquer coisa pode ser usada
• Pode-se extender uma expressão lambda com {}
• Exemplo de imprimir valores pares de uma lista:

List<Integer> lista = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
lista.forEach(n -> {
    if(n % 2 == 0){
     System.out.println(n);
    }
});

Usando Lambdas com Objetos

• Funções Lambdas podem ser utilizadas também para a ordenação de listas com a interface comparator
• Podemos usar Lambdas com Objetos também
• Exemplo de uma classe pessoa, onde coloca o nome e idade:

public class Pessoas{
    private String nome;
    private int idade;
    
    public Pessoas(String nome, int idade){
        this.nome = nome;
        this.idade = idade;
    }
    
    public String getNome(){return nome;}
    public int getIdade(){return idade;}
}

• Se quisermos ordenar em ordem alfabética os nomes:

List<Pessoas> listaPessoas = Arrays.asList(new Pessoas("Gabriel",22),new Pessoas("Alexandre",30),new Pessoas("Douglas",22));
Collections.sort(listaPessoas,(Pessoas pessoa1,Pessoas pessoa2) -> {
    pessoa1.getNome().compareTo(pessoa2.getNome())
});
listaPessoas.forEach(p -> System.out.println(p.getNome()));

• Se quisermos ordenar em ordem de idade:

List<Pessoas> listaPessoas = Arrays.asList(new Pessoas("Gabriel",22),new Pessoas("Alexandre",30),new Pessoas("Douglas",22));
Collections.sort(listaPessoas,(Pessoas pessoa1,Pessoas pessoa2) -> {
    pessoa1.getIdade().compareTo(pessoa2.getIdade())
});
listaPessoas.forEach(p -> System.out.println(p.getNome()))

Expressões Lambdas usando a API java.util.stream

• Como exemplo iremos obter a maior nota de um estudante cujo ano de graduação for 2015

• Utilizando o método privado .stream()

• Utilizando o método privado .filter()

• Utilizando o método privado .mapToDouble()

• Utilizando o método privado .max()

• RESOLUÇÃO:

public class Estudante{
  //Variaveis privada
  private String nome;
  private int anoGraduacao;
  private double nota;

 public Estudante(String n,int ano,double nota){
    nome = n;
    anoGraduacao = ano;
    this.nota = nota;
  }

  //Getters
  public String getNome(){return nome;}
  public int getAno(){return anoGraduacao;}
  public double getNota(){return nota;}
}

• Código natural de resolução:

List<Estudante> estudantes = new ArrayList<>();
double maiorNota = 0.0;
//usando ForEach
for(Estudante estudante : estudantes){
  if(estudante.getAno() == 2015){
    if(estudante.getNota() > maiorNota){
      maiorNota = estudante.getNota();
    }
  }
}

• Código usando Classes internas anônimas

List<Estudante> estudantes = new ArrayList<>();
double maiorNota
               = estudantes.stream().filter(new Predicate<Estudante>() {
                   @Override
                   public boolean test(Estudante estudante){
                      return estudante.getAno() == 2015;
                   }
               }).mapToDouble(new ToDoubleFunction<Estudante>() {
                   @Override
                   public double applyAsDouble(Estudante estudante){
                     return estudante.getNota();
                   }
               }).max().getAsDouble();

• Agora código usando Expressões Lambdas:

List<Estudante> estudantes = new ArrayList<>();
double maiorNota = estudantes.stream()
      .filter(e -> e.getAno() == 2015)
      .mapToDouble(Estudante::getNota())
      .max().getAsDouble();