Professores:
Wesley Fuchter
Link para Download do Artigo:
Repositório GitHub Aula (Professor)
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 ))));
}
}
JURANDIR JUNIOR
13/07/2021 15:23