3

Implementando Collections e Streams com Java - (Material Curso Dio)

#Java
Anderson Froes
Anderson Froes
Professores: 
Wesley Fuchter

Link para Download do Artigo:
https://drive.google.com/file/d/1_ATs074i9b2wsB-57LM8xBppcjed3sq1/view?usp=sharing

Repositório GitHub Aula (Professor)
https://github.com/wesleyfuchter/collections-course

Capitulo 1 - Collections I - List
Objetivos da Aula
Entender o uso da interface java.util.List
Entender o uso da interface java.util.Queue
Entender o uso da interface java.util.Set
Entender o uso da interface java.util.Map

Requisitos Básicos:
Java Development Kit - JDK 1.8 ou superior
Gradle
Intellij Idea IDE

java.util.List
Implementações que aprenderemos (java.util.ArrayList , java.util.Vector).
Garante ordem de inserção.
Permite adição, atualização, leitura e remoção sem regras adicionais.
Permite ordenação através de comparators.

Métodos
Método add ( );
Para adicionar um elemento.
Método sort ( );
Para ordenar os elementos.
Método set ( );
Para alterar a informação dada na posição por um outro valor.
Método remove ( );
Para remover um elemento.
Método get ( );
Para retornar uma variável o elemento dado.
Método size ( );
Para retornar um numero inteiro informando o tamanho da lista.
Método contains ( );
Para retornar um booleano true/false se existe um elemento especificado na lista.
Método isEmpty ( );
Parar retornar um booleano true/false informando se a lista tem elementos ou não.
Método clear ( );
Para limpar a lista.
Método indexOf ( );
Para retornar um número inteiro informando a posição do elemento.

Código 1 usado na aula: (O que é List e como trabalhar com ela)
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class ExemploList {
public static void main(String[] args) {
List<String> nomes = new ArrayList<>();

nomes.add("Carlos");
nomes.add("Pedro");
nomes.add("Juliana");
nomes.add("Anderson");
nomes.add("Maria");
nomes.add("João");
System.out.println(nomes);

nomes.set(2, "Larissa");
System.out.println(nomes);

Collections.sort(nomes); 

nomes.set(2, "Wesley");
System.out.println(nomes);

nomes.remove(4); 
System.out.println(nomes);

nomes.remove("Wesley"); 
System.out.println(nomes);

String nome = nomes.get(3); 
System.out.println(nomes);

int posicao = nomes.indexOf("Wesley");
System.out.println(posicao);

int tamanho = nomes.size(); 
System.out.println(tamanho);

nomes.remove("Larissa");

tamanho = nomes.size();
System.out.println(tamanho);

boolean temAnderson = nomes.contains("Anderson"); 
System.out.println(temAnderson);

boolean temFernando = nomes.contains("Fernando");
System.out.println(temFernando);

boolean listaEstaVazia = nomes.isEmpty();
System.out.println(listaEstaVazia);

for (String nomeDoItem: nomes) {
System.out.println("-->" + nomeDoItem);
}

Iterator<String> iterator = nomes.iterator();

while (iterator.hasNext()) {
System.out.println("---->" + iterator.next());
}

nomes.clear();

listaEstaVazia = nomes.isEmpty();
System.out.println(listaEstaVazia);
  
}
}

Código 2 usado na aula: (O que é List e como trabalhar com ela)
import java.util.List;
import java.util.Vector;

public class ExemploVector {
public static void main(String[] args) {
List<String> esportes = new Vector<>();

// Adiciona 4 esportes no vetor
esportes.add("Futebol");
esportes.add("Basquetebol");
esportes.add("Tênis de Mesa");
esportes.add("handebol");
System.out.println(esportes);

// Altera o valor da posição 2 do vetor
esportes.set(2, "Ping Pong");

// Remove o esporte da posição 2 do vetor
esportes.remove(2);

// Remove o esporte Handebol do vetor
esportes.remove("Handebol");
System.out.println(esportes);

// Retorna o primeiro item do vetor
System.out.println(esportes.get(0));

// Navega nos esportes
for (String esporte: esportes) {
System.out.println(esporte);
}
}
}


Capitulo 2 - O que precisamos saber sobre Java
java.util.Queue
Implementações que aprenderemos (java.util.LinkedList)
Garante ordem de inserção
Permite adição, leitura e remoção considerando a regra básica de uma fila: Primeiro que entra, primeiro que sai.
Não permite mudança de ordenação

Métodos:
poll ( );
Retorna e remove a cabeça (primeiro elemento da fila).
Retorna null se a fila estiver vazia.
element ( );
Retorna e não remove o primeiro elemento da fila.
Se a fila estiver vazia, ele retorna uma exceção (NoSuchElementException)
peek ( );
Retorna mas não remove o primeiro elemento da fila.
Retorna null se a fila estiver vazia.

Código usado na aula: (O que é Queue)
import java.util.LinkedList;
import java.util.Queue;
import java.util.Collections;
import java.util.Iterator;

public class ExemploLinkedList {

public static void main(String[] args) {

Queue<String> filaBanco = new LinkedList<>();

filaBanco.add("Patricia");
filaBanco.add("Roberto");
filaBanco.add("Flávio");
filaBanco.add("Pamela");
filaBanco.add("Anderson");
System.out.println(filaBanco);

String clienteASerAtendido = filaBanco.poll();
System.out.println(clienteASerAtendido);
System.out.println(filaBanco);

String primeiroCliente = filaBanco.peek();
System.out.println(primeiroCliente);
System.out.println(filaBanco);

for (String client: filaBanco) {
System.out.println(client);
}

Iterator<String> iteratorFilaBanco = filaBanco.iterator();

while (iteratorFilaBanco.hasNext()) {
System.out.println("--->" + iteratorFilaBanco.next());
}

filaBanco.clear();

String primeiroClienteOuErro = filaBanco.element();
System.out.println(primeiroClienteOuErro);
System.out.println(filaBanco);
System.out.println(filaBanco.size());
System.out.println(filaBanco.isEmpty());

filaBanco.add("Wesley");
System.out.println(filaBanco);

}
}


Capitulo 3 - Collections III - Set
java.util.Set
Implementações que aprenderemos (java.util.HashSet, java.util.TreeSet, java.util.LinkedHashSet)
Por padrão, não garante ordem
Não permite itens repetidos
Permite adição e remoção normalmente. Não possui busca por item e atualização. Para leitura, apenas navegação
Não permite mudança de ordenação

HashSet
Quando Utilizar
Quando não é necessário manter uma ordenação
Ordenação
Não é ordenado, e não permite valores repetidos.
Performance
Por não ter repetição de valores e não ser ordenado, é a implementação mais performática

LinkedHashSet
Quando Utilizar
Quando é necessário manter a ordem de inserção dos elementos
Ordenação
Mantém a ordem de inserção dos elementos
Performance
É a implementação mais lenta por ser necessária manter a ordem

TreeSet
Quando Utilizar
Quando é necessário alterar a ordem através do uso de comparators
Ordenação
Mantém ordem e pode ser reordenado
Performance
E performático para leitura. Para modificação tem a necessidade de reordenar, sendo mais lento que o
LinkedHashSet

Código usado na aula: (conheça a implementação mais usada em produção: HashSet)
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class ExemploHashSet {
   
  public static void main(String[] args) {
     Set<Double> notasAlunos = new HashSet<>();
   
     // Adiciona as notas no set
    notasAlunos.add(5.8);
    notasAlunos.add(9.3);
    notasAlunos.add(6.5);
    notasAlunos.add(10.0);
    notasAlunos.add(5.4);
    notasAlunos.add(7.3);
    notasAlunos.add(3.8);
    notasAlunos.add(4.0);
System.out.println(notasAlunos);
   
    // Remove a nota do set
    notasAlunos.remove(3.8);
   System.out.println(notasAlunos);
   
    // Retorna a quantidade de itens do set
    System.out.println(notasAlunos.size());
   
    // Navega em todos os itens do iterator
    Iterator<Double> iterator = notasAlunos.iterator();
   
    while (iterator.hasNext()) {
    System.out.println(iterator.next());
    }
   
    for (Double nota: notasAlunos) {
      System.out.println(nota);
    }
   
    // notasAlunos.clear();
   
    // Retorna se o set está vázio ou não
      System.out.println(notasAlunos.isEmpty());
    }
}

Código usado na aula: (Aprenda na prática sobre o LinkedHashSet)
import java.util.Iterator;
import java.util.LinkedHashSet;

public class ExemploLinkedHashSet {
  public static void main(String[] args) {
     
    LinkedHashSet<Integer> sequenciaNumerica = new LinkedHashSet<>();
     
    // Adiciona os numeros no set
    sequenciaNumerica.add(1);
    sequenciaNumerica.add(2);
    sequenciaNumerica.add(4);
    sequenciaNumerica.add(8);
    sequenciaNumerica.add(16);
   System.out.println(sequenciaNumerica);
     
    // Remove o número do set
    sequenciaNumerica.remove(4);
    System.out.println(sequenciaNumerica);
     
    // Retorna a quantidade de itens do set
    System.out.println(sequenciaNumerica.size());
     
    // Navega em todos os itens do iterator
    Iterator<Integer> iterator = sequenciaNumerica.iterator();
     
    while (iterator.hasNext()) {
      System.out.println(iterator.next());
    }
     
    for (Integer numero: sequenciaNumerica) {
      System.out.println(numero);
    }
     
    //sequenciaNumerica.clear();
     
    // Retorna se o set está vazio ou não
    System.out.println(sequenciaNumerica.isEmpty());
  }
}

Código usado na aula: (Veja sobre árvore binária e TreeSet)
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.TreeSet;

public class ExemploTreeSet {
   
  public static void main(String[] args) {
     
    TreeSet<String> treeCapitais = new TreeSet<>();
     
    // Monta a árvore com as capitais
    treeCapitais.add("Porto Alegre");
    treeCapitais.add("Florianópolis");
    treeCapitais.add("Curitiba");
    treeCapitais.add("São Paulo");
    treeCapitais.add("Rio de Janeiro");
    treeCapitais.add("Belo Horizonte");
   System.out.println(treeCapitais);
     
    // Retorna a primeira capital no topo da árvore
    System.out.println(treeCapitais.first());
     
    // Retorna a última capital no final da árvore
    System.out.println(treeCapitais.last());
     
    // Retorna a primeira capital abaixo na árvore da capital parametrizada
    System.out.println(treeCapitais.lower("Florianópolis"));
     
    // Retorna a primeira capital acima na árvore da capital parametrizada
    System.out.println(treeCapitais.higher("Florianópolis"));
     
    // Exibe todas as capitais no console
    System.out.println(treeCapitais);
     
    // Retorna a primeira capital no topo da árvore, removendo do set
    System.out.println(treeCapitais.pollFirst());
     
    // Retorna a primeira capital no final da árvore, removendo do set
    System.out.println(treeCapitais.pollLast());
     
    // Exive todas as capitais no console
    System.out.println(treeCapitais);
     
    // Navega em todos os itens do iterator
    Iterator<String> iterator = treeCapitais.iterator();
     
    while (iterator.hasNext()) {
      System.out.println(iterator.next());
    }
     
    for (String capital: treeCapitais) {
      System.out.println(capital);
    }
     
  }
}


Capitulo 4 - Collections IV - Map
java.util.Map
Implementações que aprenderemos (java.util.HashMap, java.util.TreeMap, java.util.HashTable)
Entrada de chave e valor
Permite valores repetidos, mas não permite repetição de chave.
Permite adição, busca por chave ou valor, atualização, remoção e navegação.
Pode ser ordenado.

Código 1 usado na aula: (Aprenda quando utilizar Map)
import java.util.Iterator;
import java.util.HashMap;
import java.util.Map;

public class ExemploHashMap {
  
 public static void main(String[] args) {
    
   Map<String, Integer> campeoesMundialFifa = new HashMap<>();
   
   // Adiciona os campeões mundias fifa no mapa
   campeoesMundialFifa.put("Brasil", 5);
   campeoesMundialFifa.put("Alemanha", 4);
   campeoesMundialFifa.put("Itália", 4);
   campeoesMundialFifa.put("Uruguai", 2);
   campeoesMundialFifa.put("Argentina", 2);
   campeoesMundialFifa.put("França", 2);
   campeoesMundialFifa.put("Inglaterra", 1);
   campeoesMundialFifa.put("Espanha", 1);
   System.out.println(campeoesMundialFifa);
   
   // Atualiza o valor para a chave Brasil
   campeoesMundialFifa.put("Brasil", 6);
   System.out.println(campeoesMundialFifa);
   
   // Retorna a Argentina
   System.out.println(campeoesMundialFifa.get("Argentina"));
   
   // Retorna se existe ou não um campeão França
   System.out.println(campeoesMundialFifa.containsKey("França"));
   
   // Remove o campeão França
   campeoesMundialFifa.remove("França");
   
   // Retorna se existe ou não um campeão França
   System.out.println(campeoesMundialFifa.containsKey("França"));
   
   // Retorna se existe ou não alguma seleção hexa campeã
   System.out.println(campeoesMundialFifa.containsValue("6"));
   
   // Retorna o tamanho do mapa
   System.out.println(campeoesMundialFifa.size());
   System.out.println(campeoesMundialFifa);
   
   // Navega nos registros do mapa
   for (Map.Entry<String, Integer> entry : campeoesMundialFifa.entrySet()) {
     System.out.println(entry.getKey() + "-" + entry.getValue());
   }
   
   // Navega nos registros do mapa
   for (String key : campeoesMundialFifa.keySet()) {
     System.out.println(key + "---" + campeoesMundialFifa.get(key));
   }
   
   System.out.println(campeoesMundialFifa);
   
   // Verifica se o mapa contem a chave Estados Unidos
   System.out.println(campeoesMundialFifa.containsKey("Estados Unidos"));
   
   // Verifica se o mapa contem o valor 5
   System.out.println(campeoesMundialFifa.containsValue(5));
   
   // Verifica o tamanho antes e depois de limpar o mapa
   System.out.println(campeoesMundialFifa.size());
   
   campeoesMundialFifa.clear();
   System.out.println(campeoesMundialFifa.size());
 }
   
}

Código 2 usado na aula: (Aprenda quando utilizar Map)
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

public class ExemploTreeMap {
   
  public static void main(String[] args) {
     
    TreeMap<String, String> treeCapitais = new TreeMap();
     
    // Monta a árvore com as capitais
    treeCapitais.put("RS", "Porto Alegre");
    treeCapitais.put("SC", "Florianópolis");
    treeCapitais.put("PR", "Curitiba");
    treeCapitais.put("SP", "São Paulo");
    treeCapitais.put("RJ", "Rio de Janeiro");
    treeCapitais.put("MG", "Belo Horizonte");
    System.out.print(treeCapitais);
     
    // Retorna a primeira capital no topo da árvore
    System.out.print(treeCapitais.firstKey());
     
    // Retorna a última capital no topo da árvore
    System.out.println(treeCapitais.lastKey());
     
    // Retorna a primeira capital abaixo na árvore da capital parametrizada
    System.out.println(treeCapitais.lowerKey("SC"));
     
    // Retorna a primeira capital acima na árvore da capital parametrizada
    System.out.println(treeCapitais.higherKey("SC"));
     
    // Exibe todas as capitais no console
    System.out.println(treeCapitais);
     
    // Retorna a primeira capital no topo da árvore
    System.out.println(treeCapitais.firstEntry().getKey() + "-" + treeCapitais.firstEntry().getValue());
     
    // Retorna a útilma capital no final da árvore
    System.out.println(treeCapitais.lastEntry().getKey() + "-" + treeCapitais.lastEntry().getValue());
     
    // Retorna a primeira capital abaixo na árvore da capital parametrizada
    System.out.println(treeCapitais.lowerEntry("SC").getKey() + "--" + treeCapitais.lowerEntry("SC").getValue());
     
    // Retorna a primeira capital acima na árvore da capital parametrizada
    System.out.println(treeCapitais.higherEntry("SC").getKey() + "--" + treeCapitais.higherEntry("SC").getValue());
     
    // Exibe todas as capitais no console
    System.out.println(treeCapitais);
     
    //Map.Entry<String, String> firstEntry = treeCapitais.pollFirstEntry();
    //Map.Entry<String, String> lastEntry = treeCapitais.pollLastEntry();
     
    // Retorna a primeira capital no topo da árvore, removendo do map
    System.out.println(treeCapitais.pollFirstEntry().getKey() + "---" + treeCapitais.pollFirstEntry().getValue());
     
    // Retorna a primeira capital no final da árvore removendo do map
    System.out.println(treeCapitais.pollLastEntry().getKey() + "---" + treeCapitais.pollLastEntry().getValue());

    // Exibe todas as capitais no console
    System.out.println(treeCapitais);
     
    // Navega em todas as chaves do iterator
    Iterator<String> iterator = treeCapitais.keySet().iterator();
     
    while (iterator.hasNext()) {
      String key = iterator.next();
      System.out.println(key + "-" + treeCapitais.get(key));
    }
     
    for (String capital: treeCapitais.keySet()) {
      System.out.println(capital + "--" + treeCapitais.get(capital));
    }
     
    for (Map.Entry<String, String> capital: treeCapitais.entrySet()) {
      System.out.println(capital.getKey() + "---" + capital.getValue());
    }
     
  }
   
}

Código 3 usado na aula: (Aprenda quando utilizar Map)
import java.util.Iterator;
import java.util.Map;
import java.util.Hashtable;

public class ExemploHashTable {
   
  public static void main(String[] args) {
     
    Hashtable<String, Integer> estudantes = new Hashtable<>();
     
    estudantes.put("Carlos", 21);
    estudantes.put("Mariana", 33);
    estudantes.put("Rafaela", 10);
    estudantes.put("Pedro", 44);
    System.out.println(estudantes);
     
    estudantes.put("Pedro", 55);
    System.out.println(estudantes);
     
    // Remove um estudante no indíce
    estudantes.remove("Pedro");
    System.out.println(estudantes);
     
    // Recupera um estudante no indíce
    int idadeEstudante = estudantes.get("Mariana");
    System.out.println(idadeEstudante);
    System.out.println(estudantes.size());
     
    // Navega nos registros do mapa
    for (Map.Entry<String, Integer> entry : estudantes.entrySet()) {
      System.out.println(entry.getKey() + "--" + entry.getValue());
    }
     
    // Navega nos registros do mapa
    for (String key : estudantes.keySet()) {
      System.out.println(key + "---" + estudantes.get(key));
    }
     
    System.out.println(estudantes);
  }
}


Capitulo 5 - Collections V - Comparators
Comparators
Interfaces que aprenderemos
java.util.Comparator - Interface para definir classe com regra de ordenação
java.util.Comparable - Interface para definir regra de ordenação em uma classe de domínio
Algoritmos de ordenação
Utilizado primariamente em java.util.List
Permite a ordenação de objetos complexos (criados pelo usuário)

Código 1: (Estudantes)
public class Estudante Inplements Comparable<Estudantes> {
   
  private final String nome;
  private final Integer idade;
   
  public Estudantes(String nome, Integer idade) {
    this.nome = nome;
    this.idade = idade;
  }
   
  public String getNome() { return nome; }
   
  public Integer getIdade() { return idade; }
   
  @Override
  public String toString() { return nome + " - " + idade; }
   
  @Override
  public int compareTo(Estudante o) { return this.getIdade() - o.getIdade(); }
}

Código 2: (EstudanteOrdemIdadeReversaComparator)
import java.util.Comparator;

public class EstudanteOrdemIdadeReversaComparator implements Comparator<Estudante> {
   
  @Override
  public int compare(Estudante o1, Estudante o2) {
    return o2.getIdade() - o1.getidade();
  }
}

Código 3: (ComparatorsExampleList)
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ComparatorsExampleList {
   
  public static void main(String[] args) {
     
    List<Estudante> estudantes = new ArrayList<>();
     
    estudantes.add(new Estudante("Pedro", 19));
    estudantes.add(new Estudante("Carlos", 23));
    estudantes.add(new Estudante("Mariana", 21));
    estudantes.add(new Estudante("João", 18));
    estudantes.add(new Estudante("Thiago", 20));
    estudantes.add(new Estudante("George", 22));
    estudantes.add(new Estudante("Larissa", 21));
    System.out.println("--- ordem de inserção ---");
    System.out.println(estudantes);
     
    estudantes.sort((first, second) -> first.getIdade() - second.getIdade());
    System.out.println("--- ordem natural dos números - idade ---");
    System.out.println(estudantes);
     
    estudantes.sorte((first, second) -> second.getIdade() - first.getIdade());
    System.out.println("--- ordem reversa dos números - idade ---");
    System.out.println(estudantes);
     
    estudantes.sort(Comparator.comparingInt(Estudante::getIdade));
    System.out.println("--- ordem natural dos números - idade (method reference) ---");
    System.out.println(estudantes);
     
    estudantes.sort(Comparator.comparingInt(Estudante::getIdade).reversed());
    System.out.println("--- ordem reversa dos números - idade (method reference ---");
    System.out.printl(estudantes);
     
    Collections.sort(estudantes);
    System.out.println("--- ordem natual dos números - idade (Interface Comparable) ---");
    System.out.println(estudantes);
     
    Collections.sort(estudantes, new EstudanteOrdemIdadeReversaComparator());
    System.out.println("--- ordem reversa dos números - idade (Interface Comparator) ---");
    System.out.println(estudantes);
     
  }
}


Capitulo 6 - Utilizando o Optional
Optionals:
Tratamento para valores que podem ser nulos.
Possui 2 estados (Presente) (Vazio).
Permite que você execute operações em valores que podem ser nulos sem preocupação com as famosas NullPointerExceptions.

Código 1 usado na aula: (Aprenda a criar um Optional)
import java.util.Optional;

public class ExemploOptionalEstados {
   
  public static void main(String[] args) {
     
    Optional<String> optionalString = Optional.of("Valor presente");
    System.out.println("Valor opcional que está presente");
    optionalString.ifPresentOrElse(System.out::println, () -> System.out.println("não está presente"));
     
    Optional<String> optionalNull = Optional.ofNullable(null);
    System.out.println("Valor opcional que não está presente");
    optionalNull.ifPresentOrElse(System.out::println, () -> System.out.println("null = não está presente"));
     
    Optional<String> emptyOptional = Optional.empty();
    System.out.println("Valor opcional que não está presente");
    emptyOptional.ifPresentOrElse(System.out::println, () -> System.out.println("empty = não está presente"));
     
    Optional<String> optionalNullErro = Optional.of(null);
    System.out.println("Valor opcional que lança erro NullPointerException");
    optionalNullErro.ifPresentOrElse(System.out::println, () -> System.out.println("erro = não está presente"));

  }
}

Código 2 usado na aula: (Aprenda a criar um Optional)
import java.util.OptionalDouble;
import java.util.OptionalInt;
import java.util.OptionalLong;

public class ExemploOptionalPrimitivos {
   
  public static void main(String[] args) {
     
    System.out.println("***Valor inteiro opcional***");
    OptionalInt.of(12).ifPresent(System.out::println);
     
    System.out.println("***Valor decimal opcional***");
    OptionalDouble.of(55.2).ifPresent(System.out::println);
     
    System.out.println("***Valor longo opcional***");
    OptionalLong.of(23L).ifPresent(System.out::println);
     
  }
}

Código 3 usado na aula: (Aprenda a criar um Optional)
import java.util.Optional;

public class ExemploOptional {
   
  public static void main(String[] args) {
     
    Optional<String> optionalString = Optional.of("Valor opcional");
    System.out.println(optionalString.isPresent());
    System.out.println(optionalString.isEmpty());
     
    optionalString.ifPresent(System.out::println);
     
    optionalString.ifPresentOrElse(System.out::println, 
      () -> System.out.println("Valor não está presente"));
     
    if (optionalString.isPresent()) {
      String valor = optionalString.get();
       
      System.out.println(valor);
    }
     
    optionalString.map((valor) -> valor.concat("****")).ifPresent(System.out::println);
    System.out.println(optionalString.orElseThrow(IllegalStateException::new));
       
  }
}


Capitulo 7 - Streams - Dominando fluxos de dados
Stream API
Manipulação de coleções com o paradigma funcional de forma paralela
Imutável - Não altera a coleção origem, sempre cria uma nova coleção
Principais Funcionalidades
Mapping: Retorna uma coleção com mesmo tamanho da origem com os elementos alterados
Filtering: Retorna uma coleção igual ou menor que a coleção origem, com os elementos intactos
ForEach: Executa uma determina lógica para cada elemento, retornando nada.
Peek: Executa uma determinada lógica para cada elemento, retornando a própria coleção.
Counting - Retorna um inteiro que representa a contagem de elementos.
Grouping - Retorna uma coleção agrupada de acordo com a regra definida.

Código usado na aula: (Dominando fluxos de dados)
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class ExemploStreamAPI {
   
  public static void main(String[] args) {
     
    // Cria a coleção de estudantes
    List<String> estudantes = new ArrayList<>();
     
    // Adiciona estudantes para a coleção
    estudantes.add("Pedro");
    estudantes.add("Thayse");
    estudantes.add("Marcelo");
    estudantes.add("Carla");
    estudantes.add("Juliana");
    estudantes.add("Thiago");
    estudantes.add("Rafael");
     
    // Retorna a contagem de elementos do stream
    System.out.println("Contagem: " + estudantes.stream().count());
     
    // Retorna o elemento com maior numero de letras
    System.out.println("Maior numero de letras: " + estudantes.stream().max(Comparator.comparingInt(String::length)));
     
    // Retorna o elemento com menor numero de letras
    System.out.println("Menor nunmero de letras: " + estudantes.stream().min(Comparator.comparingInt(String::length)));
     
    // Retorna os elementos que tem a letra R no nome
    System.out.println("Com a letra R no nome: " + estudantes.stream().filter((estudante) ->
        estudante.toLowerCase().contains("r")).collect(Collectors.toList()));
         
    // Retorna uma nova coleção com os nomes concatenados a quantidade de letra de cada nome
    System.out.println("Retorna uma nova coleção com a quantidade de letras: " + estudantes.stream().map(estudante -> 
        estudante.concat(" - ").concat(String.valueOf(estudante.length()))).collect(Collectors.toList()));
     
    // Retorna somente os 3 primeiros elementos da coleção
    System.out.println("Retorna os 3 primeiros elementos: " + estudantes.stream().limit(3).collect(Collectors.toList()));
     
    // Exibe cada elemento no console, e depois retorna a mesma coleção
    System.out.println("Retorna os elementos: " + estudantes.stream().peek(System.out::println).collect(Collectors.toList()));
     
    // Exibe cada elemento no console sem retornar outra coleção
    System.out.print("Retorna os elementos novamentes: ");
    estudantes.stream().forEach(System.out::println);
     
    // Retorna true se todos os elementos possuem a letra W no nome
    System.out.println("Todos os elementos tem o (w) no nome ? " + estudantes.stream().allMatch((elemento) -> elemento.contains("w")));
     
    // Retorna true se os elementos possuem a letra a minuscula no nome
    System.out.println("Tem algum elemento com (a) minusculo no nome? " + estudantes.stream().anyMatch((elemento) -> elemento.contains("a")));
     
    // Retorna o rimeiro elemento da coleção, se existir exibe no console
    System.out.print("Retorna o primeiro elemento da coleção: ");
    estudantes.stream().findFirst().ifPresent(System.out::println);
     
    // Exemplo de operação encadeada
    System.out.print("Operação encadeada: ");
    System.out.println(estudantes.stream()
        .peek(System.out::println)
        .map(estudante ->
            estudante.concat(" - ").concat(String.valueOf(estudante.length())))
        .peek(System.out::println)
        .filter((estudante) ->
            estudante.toLowerCase().contains("r"))
        .collect(Collectors.toList()));
        //  .collect(Collectors.joining(", ")));
        //  .collect(Collectors.toSet()));
        //  .collect(Collectors.groupingBy(estudante -> estudante.substring(estudante.indexOf("-") + 1 ))));
   }
}
1
71

Comentários (3)

0
JURANDIR JUNIOR

JURANDIR JUNIOR

13/07/2021 15:23

Obrigado!

0
Gustavo Nascimento

Gustavo Nascimento

16/05/2021 19:50

Muito obrigado!!!

1
Filipe Gomes

Filipe Gomes

18/02/2021 15:19

Top esse material, muito objetivo e coerente

Um ser humano buscando conhecimento e sucesso em sua vida profissional

Brasil