Java 8 - Afinal onde usamos no dia a dia? GOJava 15 anos!

Java 8
Afinal onde usamos no dia a dia?
Frederico Maia Arantes
Desenvolvedor de Sofware / Instrutor

Sobre mim
● 8 anos de experiência em desenvolvimento de software
e mais de 4 anos ministrando treinamentos
● Líder e Desenvolvedor Full Stack na TecSinapse
atuando com Java, Scala, JavaScript (Meteor)
● Cofundador e Instrutor na F7 Academy
● Palestrante em diversos eventos de tecnologia

Sobre o que iremos falar
• Default Methods
• Lambdas Expressions
• Functional Interfaces
• Streams
• Collectors

Classe ‘Ingresso’
public class Ingresso {
private String nomeEvento;
private double valor;
public Ingresso(String nomeEvento,double valor){
this.nomeEvento = nomeEvento;
this.valor = valor;
}
//getters e setters
//toString()
}

Loop tradicional
public static void main(String[] args) {
List<Ingresso> ingressos = Arrays.asList(
new Ingresso("Festa 1", 100.0),
new Ingresso("Festa 3", 200.0) );
//Percorrer os ingressos e mostrar na tela
}

Loop tradicional
for (Ingresso ingresso : ingressos) {
System.out.println(ingresso);
}
}

Novo loop com forEach
ingressos.forEach(consumer);
//Recebe um Consumer. Interface nova do Java 8
//que possui um único método
}

...
}
}
class Impressora implements Consumer<Ingresso> {
@Override
public void accept(Ingresso ingresso) {
}
}

...
Consumer<Ingresso> consumer = new Impressora();
}
}
class Impressora implements Consumer<Ingresso> {
@Override
}
}

…
Consumer<Ingresso> consumer= new Consumer<Ingresso> {
@Override
}
};

…
ingressos.forEach(new Consumer<Ingresso>(){
@Override
}
});

…
ingressos.removeIf(predicate);
//Recebe um Predicate. Interface nova do Java 8
//possui um único método que retorna um boolean
Removendo ingressos caros

ingressos.removeIf(new Predicate<Ingresso>() {
@Override
public boolean test(Ingresso ingresso) {
return ingresso.getValor() > 100;
}
});
Removendo ingressos caros

Default Methods
São novos métodos da linguagem, com
implementação, adicionados às
interfaces Java.
Como em Collections e Map.

Default methods
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
Outros: removeIf, sort, compare, computeIfPresente.
Podemos criar default methods em nossas interfaces.

Mas Galvão, a gente está
escrevendo mais código.

É... eu nem entendi
mesmo pra que isso.

Lambdas
O que são ?
De onde vem ?
De que se alimentam ?

Lambdas
@Override
}
});

Lambdas
}
});

Lambdas
ingressos.forEach(
}
);

Lambdas
ingressos.forEach(
(Ingresso ingresso) {
}
);

Lambdas
ingressos.forEach((Ingresso ingresso) {
}
);

Lambdas
ingressos.forEach((Ingresso ingresso) -> {
}
);

Lambdas
ingressos.forEach((ingresso) -> {
}
);

Lambdas
ingressos.forEach( ingresso -> {
}
);

Lambdas
ingressos.forEach( ingresso ->
System.out.println(ingresso)
);

Lambdas
ingressos.forEach(i-> System.out.println(i));

Gostei mais das Lambdas
do que Default Methods!

Mas Galvão, o legal é usar
esses recursos juntos.

Lambda é uma maneira mais simples
de implementar uma interface que
tem um único método abstrato.
Simplificando bastante, ao invés de criar
classes anônimas, usamos Lambda.

Os Default Methods que vimos
recebem interfaces que possuem um
único método abstrato.
Essas interfaces receberam um nome
especial: Functional Interfaces.

Functional Interfaces
• Interfaces com um único método abstrato.
• Exemplo, Consumer do forEach. O compilador sabe o
método que deverá ser implementado no lambda.
• Funciona só em interfaces novas do Java? Não.
• Podemos utilizar a anotação @FunctionalInterface.

button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e){
System.out.println("click!");
}
});

button.addActionListener(e ->
System.out.println("click!")
);

Gostei, mas vou nem falar
mais nada.

Streams
• Trabalhar com coleções em Java sempre envolve
muito código.
• Em muitas linguagens temos por exemplo um
‘filter’ pra facilitar nossa vida.
• Forma mais funcional de lidar com coleções.

Filtrar da forma tradicional
List<Ingresso> baratos = new ArrayList<>();
for(Ingresso ingresso : ingressos) {
if(ingresso.getValor() < 120) {
baratos.add(ingresso);
}
}

Filtrar com Stream
Stream<Ingresso> stream = ingressos.stream();

Filtrar com Stream
Stream<Ingresso> stream = ingressos.stream();
stream.filter( i -> i.getValor() < 120 );

Filtrar com Stream
ingressos.stream().filter(i->i.getValor() < 120);

Filtrar com Stream
ingressos.stream().filter(i ->i.getValor()<120);
ingressos.forEach(i -> System.out.println(i));

Filtrar com Stream
ingressos.stream().filter(i ->i.getValor()< 120);
ingressos.forEach(i -> System.out.println(i));
//imprime Festa 1, Festa 2 e Festa 3

Filtrar com Stream
ingressos.stream()
.filter(i -> i.getValor() < 120);
.forEach(i -> System.out.println(i));
//imprime Festa 1

Filtrar com Stream
ingressos.stream()
.collect(Collectors.toList());

Filtrar com Stream
List<Ingressos> baratos = ingressos.stream()
.collect(Collectors.toList());

Esse Java 8 é melhor
que o Neymar!

Obrigado!
http://fredmaia.com
http://f7academy.com.br

Java 8 - Afinal onde usamos no dia a dia? GOJava 15 anos!

Mais conteúdo relacionado

Mais procurados

Semelhante a Java 8 - Afinal onde usamos no dia a dia? GOJava 15 anos!

Mais de Frederico Maia Arantes

Java 8 - Afinal onde usamos no dia a dia? GOJava 15 anos!