Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/lsmcodes/java-stream
Resolução dos exercícios apresentados durante o curso "Ganhando Produtividade com Stream API" - DIO
https://github.com/lsmcodes/java-stream
exercises santander-bootcamp-2024 stream-api
Last synced: 10 days ago
JSON representation
Resolução dos exercícios apresentados durante o curso "Ganhando Produtividade com Stream API" - DIO
- Host: GitHub
- URL: https://github.com/lsmcodes/java-stream
- Owner: lsmcodes
- Created: 2024-05-24T19:53:53.000Z (9 months ago)
- Default Branch: main
- Last Pushed: 2024-07-04T20:08:32.000Z (7 months ago)
- Last Synced: 2024-12-02T03:15:36.643Z (2 months ago)
- Topics: exercises, santander-bootcamp-2024, stream-api
- Language: Java
- Homepage: http://www.dio.me
- Size: 25.4 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# DIO - Trilha POO Java
## Autora dos Exercícios e Repositório Original
- [Camila Cavalcante](https://github.com/cami-la)
- [Stream API Java](https://github.com/digitalinnovationone/ganhando_produtividade_com_Stream_API_Java)
## Java Stream API
A `Stream API` é uma abstração disponibilizada no Java 8 para trabalhar com coleções. Trata-se de uma poderosa solução para processar coleções de maneira `declarativa`, ao invés da tradicional e burocrática forma `imperativa`.
## Exercícios
Este repositório contém exemplos e desafios que colocam em prática os seguintes temas:
- Functional Interfaces
- Principais métodos das Stream API
## Programação Imperativa
`Programação imperativa` consiste em conjuntos de instruções detalhadas que são fornecidas ao computador para serem executadas em uma determinada ordem.
No exemplo a seguir, para fazer uma simples soma foi necessário explicitamente iterar sobre `itemList`, calcular o preço total de cada item e acumular o valor em `valorTotal`.
```java
public class CarrinhoDeCompras {
// Atributos
private List itemList;
// Construtor
public CarrinhoDeCompras() {
this.itemList = new ArrayList<>();
}
// Método para calcular valor total dos itens sem utilizar a Stream API
public double calcularValorTotal() {
double valorTotal = 0d;
if (!itemList.isEmpty()) {
for (Item item : itemList) {
double valorItem = item.getPreco() * item.getQuantidade();
valorTotal += valorItem;
}
return valorTotal;
} else {
throw new RuntimeException("A lista está vazia.");
}
}
}
```
## Programação Declarativa
`Programação declarativa` é o oposto direto da programação imperativa no sentido de que o desenvolvedor não dá instruções sobre como o computador deve executar a tarefa, mas sim sobre qual resultado é esperado.
No exemplo a seguir, para realizar a mesma soma que o exemplo anterior foi necessário apenas descrever o que deve ser feito: um stream de itens (`itemList.stream()`), transformar cada item em um valor double (`mapToDouble()`) e somar todos os valores (`sum()`).
```java
public class CarrinhoDeCompras {
// Atributos
private List itemList;
// Construtor
public CarrinhoDeCompras() {
this.itemList = new ArrayList<>();
}
// Método para calcular valor total dos itens utilizando a Stream API
public double calcularValorTotal() {
if (itemList.isEmpty()) {
throw new RuntimeException("A lista está vazia.");
}
return itemList.stream()
.mapToDouble(item -> item.getPreco() * item.getQuant())
.sum();
}
}
```
## Lambda
`Expressões lambda` permitem que classes anônimas de implementação simples sejam escritas de forma mais simplificada e clara. Também permitem que tratemos funcionalidades como argumentos e código como dados.
A sintaxe de expressões lambda consiste em uma lista de parâmetros separados por vírgula entre parênteses, o operador de seta e um corpo que pode ser uma única expressão ou um bloco de instruções: `(parameters-list) -> expression-body`.
```java
public class OrdenacaoPessoa {
// Atributo
private List pessoaList;
// Construtor
public OrdenacaoPessoa() {
this.pessoaList = new ArrayList<>();
}
public List ordenarPorAltura() {
if (!pessoaList.isEmpty()) {
List pessoasPorAltura = new ArrayList<>(pessoaList);
pessoasPorAltura.sort((p1, p2) -> Double.compare(p1.getAltura(), p2.getAltura()));
return pessoasPorAltura;
} else {
throw new RuntimeException("A lista está vazia.");
}
}
}
```
## Method Reference
As expressões lambda são usadas para criar métodos anônimos. Porém, às vezes expressões lambda não fazem nada além de invocar um método já existente e nesses casos, é frequentemente mais claro se referir ao método pelo nome. `Method references` permitem isso.
Como há diferentes tipos de method references, as sintaxes variam. O tipo de method reference que se refere a um método de instância de um determinado objeto tem sua sintaxe composta pelo objeto que contém o método, o operador de referência de método e o nome do método de instância do objeto: `containingObject::instanceMethodName`.
```java
public class OrdenacaoPessoa {
// Atributo
private List pessoaList;
// Construtor
public OrdenacaoPessoa() {
this.pessoaList = new ArrayList<>();
}
public List ordenarPorAltura() {
if (!pessoaList.isEmpty()) {
List pessoasPorAltura = new ArrayList<>(pessoaList);
pessoasPorAltura.sort(Comparator.comparingDouble(Pessoa::getAltura));
return pessoasPorAltura;
} else {
throw new RuntimeException("A lista está vazia.");
}
}
}
```
## Referências
- Java Stream API - Oracle: https://www.oracle.com/br/technical-resources/articles/java-stream-api.html
- Programming Paradigms - FreeCodeCamp: https://www.geeksforgeeks.org/difference-between-imperative-and-declarative-programming/
- Lambda Expressions - Oracle: https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#syntax
- Method References - Oracle: https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html