Programação funcional com java 8

Programação Funcional com Java 8

#TheDevConf 2015 POA

Leonardo Alves Neuwaldtwitter.com/leoneuwald

neogrid.com

http://twitter.com/leoneuwald



http://www.neogrid.com

http://www.neogrid.com

Cristian R. Silvaabout.me/ocristian@o_cristian_github.com/ocristianslideshare.net/ocristianspeakerdeck.com/ocristian

adp.com/careers/brazilcareers

http://about.me/ocristian



https://twitter.com/o_cristian_



https://github.com/ocristian



http://slideshare.net/ocristian



http://speakerdeck.com/ocristian



http://www.adp.com/careers/brazilcareers.aspx

http://www.adp.com/careers/brazilcareers.aspx

“The functional style is not counter to object-oriented programming (OOP). The real

paradigm shift is from the imperative to the declarative style of programming. With

Java 8, we can now intermix functional and OO styles of programming quite effectively. We can continue to use the OOP

style to model domain entities, their states, and their relationships. In addition, we can model the behavior

or state transformations, business workflows, and data processing as a series of functions to form a

function composition.”

O que realmente muda no nosso dia-a-dia usando programação

funcional com Java 8?

Ordenando e exibindo uma listafor (Jogador jogador : listaJogadores) {

if (Posicao.ATACANTE.equals(jogador.getPosicao())) {listaAtacantes.add(jogador);

}}Collections.sort(listaAtacantes, new Comparator<Atletas>() {

@Overridepublic int compare(Jogador j1, Jogador j2) {

return j1.getNome().compareTo(j2.getNome());}

});for (Jogador jogador : listaAtacantes) {

System.out.println(jogador);} 6

Ordenando e exibindo uma lista

listaJogadores.removeIf(jogador -> !Posicao.ATACANTE.equals(jogador.getPosicao()));

listaJogadores.sort((a1, a2) -> a1.getNome().compareTo(a2.getNome()));

listaJogadores.forEach(System.out::println);

7

// Java 8listaJogadores.sort((j1, j2) -> j1.getNome().compareTo(j2.getNome()));

Collections.sort(listaAtacantes, new Comparator<Jogador>() {@Overridepublic int compare(Jogador j1, Jogador j2) {


});

8




});

9




});

10

// Java 8listaJogadores.removeIf(jogador -> !Posicao.ATACANTE.equals(jogador.getPosicao()));

for (Jogador jogador : listaJogadores) {if (Posicao.ATACANTE.equals(jogador.getPosicao())) {

listaAtacantes.add(jogador);}

}

11

// Java 8listaJogadores.forEach(System.out::println);

for (Jogador jogador : listaAtacantes) {System.out.println(jogador);

}

12

listaJogadores.stream().filter(jogador -> Posicao.ATACANTE.equals(jogador.getPosicao())).sorted(Comparator.comparing(Jogador::getNome)).forEach(System.out::println);

13

listaJogadores.parallelStream().filter(jogador -> Posicao.ATACANTE.equals(jogador.getPosicao())).sorted(Comparator.comparing(Jogador::getNome)).forEach(System.out::println);

14

15

+ legibilidade de código+ foco no negócio+ código mais expressivo+ facilidade de paralelizar o código- probabilidade de erro- código imperativo- mutabilidade

O que vamos ver então?Lambda

Functional interfacesMethod reference

Default methodsCollections APIStreams

16

● Anonima○ não possui nome

● Função○ não é vinculada a classe

● Concisa○ não possui código boilerplate

● Pode ser repassada○ como argumento ou variável

Lambda Expression

17

Anonymous class:Collections.sort(listaAtacantes, new Comparator<Jogador>() {

@Overridepublic int compare(Jogador j1, Jogador j2) {


});

Lambda:listaJogadores.sort((j1, j2) -> j1.getNome().compareTo(j2.getNome()));

Lambda Expression

18

Lambda Expression

( parametros ) -> { corpo da expressão lambda }

19

Lambda Expression

( parametros ) -> { corpo da expressão lambda }

20

Lambda Expression

() -> System.out.println("Lambda em uma linha")

21

Lambda Expression

x -> x + 10

22

Lambda Expression

(String a, String b) -> {if ( a.length() > b.length() )

return a;return b;

};

23

Comparator<Jogador> c1 = (Jogador j1, Jogador j2) ->a1.getNome().compareTo(a2.getNome());

Predicate<Jogador> pre = (Jogador j1) -> a1.getNome().startsWith("N");

Object o = (Jogador a1, Jogador a2) ->a1.getNome().compareTo(a2.getNome());

Atribuindo Lambda para variável

//The target type of this expression must be a functional interface

24

● Interface com 1 único método abstrato○ Default Methods

● @FunctionalInterface

Functional Interfaces

25

package java.util.function;import java.util.Objects;

@FunctionalInterfacepublic interface Function<T, R> {

R apply(T t);

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));

}// … more default and static methods

}26

Function<Jogador, Integer> idadeAnos = (Jogador jogador) -> {return Period.between(jogador.getDataNascimento(), LocalDate.now())

.getYears();};

System.out.println(idadeAnos.apply(jogador)); //Imprime 30

Function

27

java.util.function.BiConsumer<T,U>

java.util.function.BiFunction<T,U,R>

java.util.function.BinaryOperator<T>

java.util.function.BiPredicate<T,U>

java.util.function.BooleanSupplier

java.util.function.Consumer<T>

java.util.function.DoubleBinaryOperator

java.util.function.DoubleConsumer

java.util.function.DoubleFunction<R>

java.util.function.DoublePredicate

java.util.function.DoubleSupplier

java.util.function.DoubleToIntFunction

java.util.function.DoubleToLongFunction

java.util.function.DoubleUnaryOperator

Package java.util.function

28

java.util.function.Function<T,R>

java.util.function.UnaryOperator<T>

java.util.function.IntBinaryOperator

java.util.function.IntConsumer

java.util.function.IntFunction<R>

java.util.function.IntPredicate

java.util.function.IntSupplier

java.util.function.IntToDoubleFunction

java.util.function.IntToLongFunction

java.util.function.IntUnaryOperator

java.util.function.LongBinaryOperator

java.util.function.LongConsumer

java.util.function.LongFunction<R>

java.util.function.LongPredicate

java.util.function.LongSupplier

java.util.function.LongToDoubleFunction

java.util.function.LongToIntFunction

java.util.function.LongUnaryOperator

java.util.function.ObjDoubleConsumer<T>

java.util.function.ObjIntConsumer<T>

java.util.function.ObjLongConsumer<T>

java.util.function.Predicate<T>

java.util.function.Supplier<T>

java.util.function.ToDoubleBiFunction<T,U>

java.util.function.ToDoubleFunction<T>

java.util.function.ToIntBiFunction<T,U>

java.util.function.ToIntFunction<T>

java.util.function.ToLongBiFunction<T,U>

java.util.function.ToLongFunction<T>

// Sem Type InferenceComparator<Jogador> c1 = (Jogador a1, Jogador a2) ->

a1.getNome().compareTo(a2.getNome());

// Com Type InferenceComparator<Jogador> c1 = (a1, a2) -> a1.getNome().compareTo(a2.getNome());

Type inference

29

Mesma Lambda, diferentes Functional Interfaces

30

● Mesma Lambda, duas Functional Interface diferentes

Comparator<Jogador> c = (a1, a2) -> a1.getNome().compareTo(a2.getNome());

BiFunction<Jogador, Jogador, Integer> c = (a1, a2) -> a1.getNome().compareTo(a2.getNome());

31

Dois métodos com mesmo nome, recebendo diferentes Functional Interfaces, porém que aceitam a mesma Lambda

private void testTypeChecking(BiFunction<Jogador, Jogador, Integer> lambda)

private void testTypeChecking(Comparator<Jogador> lambda)

Ao chamar o método

testTypeChecking((a1, a2) -> a1.getNome().compareTo(a2.getNome()));

o compilador apresenta o erro: The method testTypeChecking(Comparator<Jogador>) is ambiguous for the type class ...

32

● … porém se passarmos o objeto comp o compilador sabe qual método chamar

Comparator<Jogador> comp = (a1, a2) -> a1.getNome().compareTo(a2.getNome());

testTypeChecking(comp);

private String scope = "class";

Comparator<Jogador> c1 = (a1, a2) -> {String scope = "lambda";System.out.println(this.scope);return a1.getNome().compareTo(a2.getNome());

};

listaJogadores.sort(new Comparator<Jogador>() {String scope = "anonymous";@Overridepublic int compare(Jogador o1, Jogador o2) {

System.out.println(this.scope);return o1.getNome().compareTo(o2.getNome());

}});

This Scope

Imprime: class

Imprime: anonymous

33

private String readOneLine() throws IOException {

try (BufferedReader br = new BufferedReader(new InputStreamReader(getClass().getClassLoader()

.getResourceAsStream("document.txt")))) {return br.readLine();

}}

34

passando comportamento por paramentro

private String readTwoLine() throws IOException {

try (BufferedReader br = new BufferedReader(new InputStreamReader(getClass().getClassLoader()

.getResourceAsStream("document.txt")))) {return br.readLine() + br.readLine();

}}

35

@FunctionalInterfacepublic interface BufferedReaderProcessor {

String process(BufferedReader br) throws IOException;}

36

private String readLine(BufferedReaderProcessor p) throws IOException {try (BufferedReader br = new BufferedReader(

new InputStreamReader(getClass().getClassLoader().getResourceAsStream("document.txt")))) {

return p.process(br);}

}

//main...readLine((br) -> br.readLine());readLine((br) -> br.readLine() + br.readLine());readLine((br) -> br.readLine() + br.readLine());….

37

Compose LambdasPredicate<Jogador> filter = //...

filter.and((Jogador j) -> Posicao.ATACANTE.equals(j.getPosicao())).or((Jogador j) -> Posicao.MEIO_CAMPO.equals(j.getPosicao())).and((Jogador j) -> j.getNome().startsWith("C"));

//Predicate do Java...public interface Predicate<T> {

boolean test(T t);

default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);

}38

Method References● Permite referenciar métodos ou construtores usando ::● Como se fosse uma abreviação de uma lambda, chamando somente um

método

Lambda:Consumer<String> consumer = (String s) -> System.out.println(s)

Method Reference:Consumer<String> consumer = System.out::println

39

Método BinaryOperator<String> ct = String::concat; String result = ct.apply("Lam", "bda"); System.out.println(result);// Imprime Lambda

Lambda:BinaryOperator<String> ct = (String str2, String str1) -> str1.concat(str2);

40

Construtor

BiFunction<String, String, Equipe> build = Equipe::new;Equipe barcelona = build.apply("Futbol Club Barcelona", "Barcelona");

Lambda:BiFunction<String, String, Equipe> build =

(nomeCompleto, nome) -> new Equipe(nomeCompleto, nome);

41

Usando Method ReferenceslistaJogadores.sort(Comparator.comparing(Jogador::getNome)

.thenComparing(Jogador::getPosicao)

.thenComparing(Jogador::getDataNascimento));

artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) ).collect(Collectors.groupingBy(

Artilharia::getEquipeNome, Collectors.counting()));

42

java.util.Stream

Streams API

iterando coleções

List<String> times = brasileirao.getClassificacao().stream().map(c -> c.getEquipe().getNomePopular()).distinct().collect(Collectors.toList());

times.forEach(System.out::println);

45

o que é um Stream

Stream Operations

Source Intermediate Operation

Intermediate Operation

Terminal Operation

Stream Pipeline

49

Source Intermediate Operations

Intermediate Operations

Terminal Operations

Stream Pipeline

50

ArraysCollection<E>FilesRandomBufferedReaderStream

Source

Stream

51



Terminal Operation

Stream Pipeline

52



Terminal Operation

Stream Pipeline

53

List<Artilharia> atacantes = artilharia.stream()

.filter( j -> "Atacante".equals( j.getJogadorPosicao() )


.filter( Predicate p )

54

List<String> nomesDosAtacantes = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) )

.map( j -> j.getJogadorNome().toUpperCase() )

.collect( Collectors.toList() );


.map( Function f )

55


.flatMap( Function f )

map map

1 - to - 1

map map

1 - to - n

Map

FlatMap

56


.sorted( Comparator.comparing( Artilharia::getTotalGols ) )



.sorted( Comparator c )

57


.distinct( )



.distinct( )

58


.peek( j -> System.out.println( j.getJogadorNome() ))

.distinct()



.peek( Consumer c )

59


.skip( 10 )



.skip( long n )

60


.limit( 10 )



.limit( long n )

61



Terminal Operation

Stream Pipeline

62



Terminal Operations

Stream Pipeline

63



Terminal Operation

.collect( Collector c )

64

Map<String, Integer> atacanteETotalDeGols = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) )

.collect( Collectors.toMap( j -> j.getJogadorNome(), j -> j.getTotalGols() ) );

Terminal Operation


65

Map<String, Long> atacantesPorTime = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) )

.collect(Collectors.groupingBy(

Artilharia::getEquipeNome, Collectors.counting() ) );

Terminal Operation


66

artilharia.stream().filter( j -> "Atacantes".equals( j.getJogadorPosicao() ) )

.forEach( j ->

System.out.println( j.getJogadorNome() + " - " + j.getTotalGols() ) );

Terminal Operation

.forEach( Consumer c )

67

List<String> nomesDosAtacantes = artilharia.stream().filter( j -> "Atacantes".equals( j.getJogadorPosicao() ) ).collect( Collectors.toList() );

nomesDosAtacantes.forEach( System.out::println );

Terminal Operation

.forEach( Consumer c )

68

OptionalLong numeroDeGols = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) ).mapToLong( Artilharia::getTotalGols )

.min();

Terminal Operation

.min( Comparator c )

69

OptionalLong numeroDeGols = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) ).mapToLong( Artilharia::getTotalGols )

.max();

Terminal Operation

.max( Comparator c )

70

long numeroDeAtacantes = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) )

.count();

Terminal Operation

.count( )

71

long totalDeGolsDeAtacantes = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) ).mapToLong( Artilharia::getTotalGols )

.sum();

Terminal Operation

.sum( )

72

long totalDePartidas = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) ).mapToLong( Artilharia::getTotalPartidas )

.reduce(0, (a, b) -> a + b);

Terminal Operation

.reduce( BinaryOperator b )

73

long reduce = LongStream.of(1, 2, 3, 4).reduce(0, (a, b) -> a + b);

Terminal Operation

.reduce( BinaryOperator b )

74

Optional<Artilharia> primeiroAtacanteArtilheiro = artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) )

.findFirst();

Terminal Operation

.findFirst( )

75

Cuidado com a ordem das operações!

Stream().of("alpha", "bravo", "charlie", "delta", "echo", "foxtrot").map( j -> {

System.out.println("map: " + j.toUpperCase() );return j.toUpperCase();

} ).filter( j -> {

System.out.println("filter: " + j );return j.startsWith("A");

} ).forEach( j -> {

System.out.println("forEach: " + j );});

76

map: ALPHAfilter: ALPHAforEach: ALPHAmap: BRAVOfilter: BRAVOmap: CHARLIEfilter: CHARLIEmap: DELTAfilter: DELTAmap: ECHOfilter: ECHOmap: FOXTROTfilter: FOXTROT


6 x map

77

Cuidado com a ordem das operações!Stream().of("alpha", "bravo", "charlie", "delta", "echo", "foxtrot")

.filter( j -> {System.out.println("filter: " + j );return j.startsWith("a");

} ).map( j -> {

System.out.println("map: " + j.toUpperCase() );return j.toUpperCase();

} ).forEach( j -> {

System.out.println("forEach: " + j );});

78

filter: alpha

map: ALPHA

forEach: ALPHAfilter: bravofilter: charliefilter: deltafilter: echofilter: foxtrot


1 x map

79

operações LazyStream.of(

"Whatever", "it", "takes", "to", "break", "Gotta", "do", "it", "From", "the", "burning", "lake", "or", "the", "eastern", "gate", "You'll", "get", "through", "it" ).filter( j -> j.startsWith("t") ).map( j -> j.toUpperCase() ).findFirst();

"Whatever" "it", "takes""to""break""Gotta""do""it"

startsWith("t") toUpperCase() findFirst()"takes" "TAKES"

80

List<Artilharia> atacantes = artilharia.stream()

.filter( j -> "Atacante".equals( j.getJogadorPosicao() ) )

.sorted( Comparator.comparing(Artilharia::getTotalGols).reversed() )


o que como

81

Parallel Stream

artilharia.stream().filter( j -> "Atacante".equals( j.getJogadorPosicao() ) )



83

artilharia

.filter( j -> "Atacante".equals( j.getJogadorPosicao() ) )



.parallelStream()

84

fork-join framework

85

quando usar parallelStream()

86

Estrutura de dados

ArrayList<E>HashSet, TreeSetLinkedList

Tamanho da Coleção

Operações

filter()map()

sorted()distinct()

87

N = tamanho da coleçãoQ = custo por elemento no pipeline da streamN x Q = custo total do pipeline

quanto maior N x Q melhor será a execução em paralelo

88

Simon Ritter Oracle Java Technology Evangelist

ReferênciasJava 8 in ActionLambdas, streams, and functional-style programming

Functional Programming in Java

Introducing Java 8A Quick-Start Guide to Lambdas and Streams

Java 8 PráticoLambdas, Streams e os novos recursos da linguagem

https://www.manning.com/books/java-8-in-action





http://www.amazon.com/Functional-Programming-Java-Harnessing-Expressions/dp/1937785467

http://www.oreilly.com/programming/free/introducing-java-8.csp?cmp=tw-prog-free-product-lgen__introducing_java_8

http://www.casadocodigo.com.br/products/livro-java8

Obrigado!

Leonardo Neuwaldtwitter.com/leoneuwald

Cristian R. Silvaabout.me/ocristian



Programação funcional com java 8

Technology

Transcript of Programação funcional com java 8