Executando verificação de segurança...
1
seujorge
8 min de leitura ·

Funcionalidades do JDK 8 (Java 8) - Parte X - API de Streams

Aplicação da API de Streams Parte II

Gerando mapas com coletores

Podemos gerar um stream com todas as linhas dos arquivos que lemos de um determinado diretório:

Stream<String> stream = Files.list(Paths.get(ROOT_PATH))
        .filter(path -> path.toString().endsWith(".txt"))
        .flatMap(path -> lines(path));

Podemos ainda ter um stream com a quantidade de linhas de cada arquivo, basta em vez de usar o flatMap() utilizar um map() para a quantidade de linhas, usando o count(), veja:

List<Long> linhas = Files.list(Paths.get(ROOT_PATH))
        .filter(path -> path.toString().endsWith(".txt"))
        .map(path -> lines(path).count())
        .collect(Collectors.toList());

Agora e se desejarmos saber quantas linhas tem cada arquivo nesse diretório ? Podemos fazer um forEach() e popular um Map<Path, Long> no qual a chave é o arquivo e o valor é a quantidade de linhas dele:

Map<Path, Long> linesInFile = new HashMap<>();

Files.list(Paths.get(ROOT_PATH))
        .filter(path -> path.toString().endsWith(".txt"))
        .forEach(path -> linesInFile.put(path, lines(path).count()));

Esse código vai produzir uma saída mais ou menos assim:

{/home/seujorge/meu_arquivo.txt=52}

Isso já é bom, já que sob esse approach nos livramos de coisas com oBufferedReaders e loops, porém essa solução não é muito funcional, note que a lambda passada para o forEach() utiliza uma variável que está declarada fora do seu escopo, assim a lambda altera o estado dessa variável gerando efeitos colaterais, o que afetaria coisas como paralelismo, para resolver esse problema podemos fazer da seguinte forma:

Map<Path, Long> linesInFile = Files.list(Paths.get(ROOT_PATH))
        .filter(path -> path.toString().endsWith(".txt"))
        .collect(Collectors.toMap(path -> path, path -> lines(path).count()));

O toMap() recebe duas Functions. A primeira produzirá a chave (o path) e a segunda o valor (quantidade de linhas), é bem comum precisarmos de uma lambda que retorna o próprio argumento, como fazemos em path -> path,, nesse caso podemos utilizar Function.identity() para deixar mais claro:

Map<Path, Long> linesInFile = Files.list(Paths.get(ROOT_PATH))
        .filter(path -> path.toString().endsWith(".txt"))
        .collect(Collectors.toMap(Function.identity(), path -> lines(path).count()));

Sendo assim saiba que sempre que uma lambda tiver um arquivo tipo algumaCoisa -> algumaCoisa, você pode utilizar Function.identity().

Outro exemplo de uso para Function.identity(), imagina que queremos mapear todos os pilotos utilizando seus nomes como chave:

A princípio teríamos o seguinte código:

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        Piloto prost = new Piloto("Prost", 122, false);
        Piloto gasly = new Piloto("Gasly", 180, false);
        Piloto leclerc = new Piloto("Leclerc", 789, false);
        Piloto senna = new Piloto("Senna", 1000, true);
        Piloto albon = new Piloto("Albon", 562, false);
        Piloto tsunoda = new Piloto("Tsunoda", 967, false);
        Piloto bottas = new Piloto("Bottas", 609, false);
        Piloto hamilton = new Piloto("Hamilton", 967, true);
        Piloto verstappen = new Piloto("Verstappen", 890, true);

        List<Piloto> pilotos = Arrays.asList(prost, gasly, leclerc, senna, albon, tsunoda, bottas, hamilton, verstappen);

        Map<String, Piloto> nomes = pilotos.stream()
                .collect(Collectors.toMap(Piloto::getNome, piloto -> piloto));

        System.out.println(nomes);
    }
}

Note que passamos ao toMap() um argumento piloto -> piloto, podemos alterar esse argumento para Function.identity()

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        Piloto prost = new Piloto("Prost", 122, false);
        Piloto gasly = new Piloto("Gasly", 180, false);
        Piloto leclerc = new Piloto("Leclerc", 789, false);
        Piloto senna = new Piloto("Senna", 1000, true);
        Piloto albon = new Piloto("Albon", 562, false);
        Piloto tsunoda = new Piloto("Tsunoda", 967, false);
        Piloto bottas = new Piloto("Bottas", 609, false);
        Piloto hamilton = new Piloto("Hamilton", 967, true);
        Piloto verstappen = new Piloto("Verstappen", 890, true);

        List<Piloto> pilotos = Arrays.asList(prost, gasly, leclerc, senna, albon, tsunoda, bottas, hamilton, verstappen);

        Map<String, Piloto> nomes = pilotos.stream()
                .collect(Collectors.toMap(Piloto::getNome, Function.identity()));

        System.out.println(nomes);
    }
}

Se a classe Piloto fosse uma entidade JPA poderíamos mapear o id e o nome, assim:

pilotos.stream()
        .collect(Collectors.toMap(Piloto::getId, Function.identity()));

Agrupando e particionando

Temos na classe Piloto um booleano para dizer se o piloto é ou não um campeão mundial, vamos revistar a classe para lembrar

package br.com.jorgerabellodev.streams.model;

public class Piloto {
    private String nome;
    private int pontuacao;
    private boolean campeaoMundial;

    public Piloto(String nome, int pontuacao) {
        this.nome = nome;
        this.pontuacao = pontuacao;
    }

    public Piloto(String nome, int pontuacao, boolean campeaoMundial) {
        this.nome = nome;
        this.pontuacao = pontuacao;
        this.campeaoMundial = campeaoMundial;
    }

    public String getNome() {
        return nome;
    }

    public int getPontuacao() {
        return pontuacao;
    }

    public boolean isCampeaoMundial() {
        return campeaoMundial;
    }

    public void tornarCampeaoMundial() {
        this.campeaoMundial = true;
    }

    @Override
    public String toString() {
        return "Piloto{" +
                "nome='" + nome + '\'' +
                ", pontuacao=" + pontuacao +
                ", campeaoMundial=" + campeaoMundial +
                '}';
    }
}

Agora vamos criar alguns pilotos

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        Piloto prost = new Piloto("Prost", 100, false);
        Piloto gasly = new Piloto("Gasly", 100, false);
        Piloto leclerc = new Piloto("Leclerc", 289, false);
        Piloto senna = new Piloto("Senna", 1000, true);
        Piloto albon = new Piloto("Albon", 562, false);
        Piloto tsunoda = new Piloto("Tsunoda", 967, false);
        Piloto bottas = new Piloto("Bottas", 609, false);
        Piloto hamilton = new Piloto("Hamilton", 1000, true);
        Piloto verstappen = new Piloto("Verstappen", 890, true);

        List<Piloto> pilotos = Arrays.asList(prost, gasly, leclerc, senna, albon, tsunoda, bottas, hamilton, verstappen);

        System.out.println(pilotos);
    }
}

Agora queremos um mapa em que a chave seja a pontuação do piloto e o valor seja uma lista de pilotos que possuem aquela pontuação, ou seja queremos um Map<Integer, List<Piloto>. Com Java 8 nossa implementação vai ficar mais ou menos assim:

Map<Integer, List<Piloto>> pontuacoesPorPilotos = new HashMap<>();

for (Piloto piloto : pilotos) {
    pontuacoesPorPilotos.computeIfAbsent(piloto.getPontuacao(), driver -> new ArrayList<>()).add(piloto);
}

O código todo fica assim:

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Piloto prost = new Piloto("Prost", 100, false);
        Piloto gasly = new Piloto("Gasly", 100, false);
        Piloto leclerc = new Piloto("Leclerc", 289, false);
        Piloto senna = new Piloto("Senna", 1000, true);
        Piloto albon = new Piloto("Albon", 562, false);
        Piloto tsunoda = new Piloto("Tsunoda", 967, false);
        Piloto bottas = new Piloto("Bottas", 609, false);
        Piloto hamilton = new Piloto("Hamilton", 1000, true);
        Piloto verstappen = new Piloto("Verstappen", 890, true);

        List<Piloto> pilotos = Arrays.asList(prost, gasly, leclerc, senna, albon, tsunoda, bottas, hamilton, verstappen);

        Map<Integer, List<Piloto>> pontuacoesPorPilotos = new HashMap<>();

        for (Piloto piloto : pilotos) {
            pontuacoesPorPilotos.computeIfAbsent(piloto.getPontuacao(), driver -> new ArrayList<>()).add(piloto);
        }

        System.out.println(pontuacoesPorPilotos);
    }
}

Até o Java 7 precisaríamos de muito mais código para executar essa mesma ação.

O método computeIfAbsent() chama a Function da lambda no caso de não encontrar um valor para a chave piloto.getPontuacao() e associar o resultado (a nova ArrayList) a essa mesma chave, essa chamada para computeIfAbsent() faz o papel de um if que seria necessário nesse fluxo.

Esse código funciona, mas queremos trabalhar com streams, então poderíamos pensar em escrever um Collector ou trabalhar com o reduce() como já vimos, porém existe um Collector que faz exatamente isso:

Assim teríamos um mapa com as pontuações

Map<Integer, List<Piloto>> pontuacoesPorPilotos = pilotos.stream()
        .collect(Collectors.groupingBy(Piloto::getPontuacao));

Veja que temos o mesmo resultado do código anterior mas com menos código.

Agora imagina que queremos particionar os pilotos em campeões mundiais e não campeões mundiais. Para essa finalidade existe o partitioningBy()

Map<Boolean, List<String>> campeoesENaoCampeoes = pilotos.stream()
        .collect(Collectors.partitioningBy(Piloto::isCampeaoMundial, Collectors.mapping(Piloto::getNome, Collectors.toList())));

O código todo seria assim

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        Piloto prost = new Piloto("Prost", 100, false);
        Piloto gasly = new Piloto("Gasly", 100, false);
        Piloto leclerc = new Piloto("Leclerc", 289, false);
        Piloto senna = new Piloto("Senna", 1000, true);
        Piloto albon = new Piloto("Albon", 562, false);
        Piloto tsunoda = new Piloto("Tsunoda", 967, false);
        Piloto bottas = new Piloto("Bottas", 609, false);
        Piloto hamilton = new Piloto("Hamilton", 1000, true);
        Piloto verstappen = new Piloto("Verstappen", 890, true);

        List<Piloto> pilotos = Arrays.asList(prost, gasly, leclerc, senna, albon, tsunoda, bottas, hamilton, verstappen);

        Map<Boolean, List<String>> campeoesENaoCampeoes = pilotos.stream()
                .collect(Collectors.partitioningBy(Piloto::isCampeaoMundial, Collectors.mapping(Piloto::getNome, Collectors.toList())));

        System.out.println(campeoesENaoCampeoes);
    }
}

Vamos tentar somar todas as pontuações dos campeões mundiais e dos campeões mundiais, separadamente, podemos fazer isso facilmente da seguinte forma:

Map<Boolean, Integer> pontuacoes = pilotos.stream()
        .collect(Collectors.partitioningBy(Piloto::isCampeaoMundial, Collectors.summingInt(Piloto::getPontuacao)));

Note que até o momento não utilizamos mais loops e mesmo se precisarmos concatenar os nomes dos usuários também seria fácil:

Imagina que queremos a seguinte saída

Prost, Gasly, Leclerc, Senna, Albon, Tsunoda, Bottas, Hamilton, Verstappen

Poderíamos obte-la facilmente assim:

String nomesDosPilotos = pilotos.stream()
        .map(Piloto::getNome)
        .collect(Collectors.joining(", "));

Com streams e collectors podemos escrever código mais enxuto em estilo funcional e consequentemente mais expressivo. Além disso produzimos menos efeitos colaterais favorecendo a imutabilidade das coleções e facilitando a paralelização.

Executando o pipeline em paralelo

Vamos voltar ao exemplo em que precisamos filtrar os pilotos com mais de 900 pontos

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        Piloto prost = new Piloto("Prost", 100, false);
        Piloto gasly = new Piloto("Gasly", 100, false);
        Piloto leclerc = new Piloto("Leclerc", 289, false);
        Piloto senna = new Piloto("Senna", 1000, true);
        Piloto albon = new Piloto("Albon", 562, false);
        Piloto tsunoda = new Piloto("Tsunoda", 967, false);
        Piloto bottas = new Piloto("Bottas", 609, false);
        Piloto hamilton = new Piloto("Hamilton", 1000, true);
        Piloto verstappen = new Piloto("Verstappen", 890, true);

        List<Piloto> pilotos = Arrays.asList(prost, gasly, leclerc, senna, albon, tsunoda, bottas, hamilton, verstappen);


        List<Piloto> pilotosComMaisDe900Pontos = pilotos.stream()
                .filter(piloto -> piloto.getPontuacao() > 900)
                .sorted(Comparator.comparing(Piloto::getNome))
                .collect(Collectors.toList());

        System.out.println(pilotosComMaisDe900Pontos);
    }
}

Nesse exemplo tudo acontece na mesma thread, se tivermos uma lista muito grande o processo poderá levar muito tempo travando essa thread até que termine sua execução. Seria interessante paralelizar esse processo, visto que atualmente a maioria dos dispositivos, se não todos eles, possuem mais de um processador, ou núcleo de processador, porém escrever código que use Thread para filtrar, ordenar e coletar pode ser trabalhoso. Poderíamos trabalhar com Fork/Join mas mesmo assim teríamos bastante trabalho.

A boa notícia é que as collections oferecem uma implementação de stream diferente, o stream paralelo. Esse stream tem capacidade para decidir quantas threads deve utilizar, como deve quebrar o processamento de dados e qual será a forma de unir o resultado.

Para utilizar basta no lugar de invocar o método stream() invocar parallelStream()

List<Piloto> pilotosComMaisDe900Pontos = pilotos.parallelStream()
        .filter(piloto -> piloto.getPontuacao() > 900)
        .sorted(Comparator.comparing(Piloto::getNome))
        .collect(Collectors.toList());

Sendo assim nosso código ficaria assim:

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        Piloto prost = new Piloto("Prost", 100, false);
        Piloto gasly = new Piloto("Gasly", 100, false);
        Piloto leclerc = new Piloto("Leclerc", 289, false);
        Piloto senna = new Piloto("Senna", 1000, true);
        Piloto albon = new Piloto("Albon", 562, false);
        Piloto tsunoda = new Piloto("Tsunoda", 967, false);
        Piloto bottas = new Piloto("Bottas", 609, false);
        Piloto hamilton = new Piloto("Hamilton", 1000, true);
        Piloto verstappen = new Piloto("Verstappen", 890, true);

        List<Piloto> pilotos = Arrays.asList(prost, gasly, leclerc, senna, albon, tsunoda, bottas, hamilton, verstappen);


        List<Piloto> pilotosComMaisDe900Pontos = pilotos.parallelStream()
                .filter(piloto -> piloto.getPontuacao() > 900)
                .sorted(Comparator.comparing(Piloto::getNome))
                .collect(Collectors.toList());

        System.out.println(pilotosComMaisDe900Pontos);
    }
}

Para esse pequeno exemplo, não faz muita diferença mas em sistemas distribuídos grandes, com uma alta volumetria de dados a performance agradeceria !

Espero que este artigo tenha sido útil e que quem leu tenha, assim como eu, compreendido melhor a API de streams.

A nossa última parte vai falar sobre a API de datas !

Carregando publicação patrocinada...