Liberando o poder do Java 8: o guia definitivo para seus principais recursos
Java 8 introduziu vários novos recursos que ajudaram a torná-lo mais versátil e flexível. O recurso Java 8 possibilita a programação funcional . Aqui estão alguns dos principais recursos do Java 8:
- Expressões Lambda
- Interfaces Funcionais
- API de transmissão
- Métodos Padrão
- Referências de método
- Opcional
- API de data/hora
1. Expressões Lambda
Usando expressões lambda podemos representar um bloco de código que pode ser executado posteriormente.
As expressões lambda são usadas para definir funções anônimas , que podem ser passadas como argumentos de método ou podem ser retornadas de métodos como qualquer outro objeto.
Sintaxe da expressão lambda:
(parameters) -> { statements };
Exemplos:
(i) sem argumentos
()-> System.out.println("lambda expression with no arguments");
// lambda expression with one argument
(a) -> System.out.println(String.format("Value of a is: %s", a);
// lambda expression with multiple arguments
(a, b) -> a + b;
// also argument type can be provided explicitely
(Integer a, Integer b) -> a + b;
(Integer a, Integer b) -> { // parentheses needed for multiple statements
System.out.println(String.format("Returning maximum from %s and %s", a, b));
return (a > b) a : b;
};
// functional interface, we will see below in detail
interface MaxFinder {
int findMax(int a, int b);
}
public class LambdaExpressionExample {
public static void main(String[] args) {
// return maximum of two numbers using lambda expression
MaxFinder maxFinder = (a, b) -> (a > b) ? a : b;
System.out.println(maxFinder.findMax(5, 10));
System.out.println(maxFinder.findMax(15, 5));
}
}
Agora, vamos ver como a expressão lambda pode ser usada com o loop forEach :
public class LambdaExpressionExample {
public static void main(String[] args) {
List<Integer> nums = new ArrayList<>();
nums.add(1);
nums.add(2);
nums.add(3);
nums.add(4);
nums.forEach(num -> System.out.println(String.format("Square of %s is %s", num, num * num)));
}
}
2. Interfaces Funcionais
Uma interface que tem exatamente um método abstrato é chamada de interface funcional e também chamada de Interfaces de Método Abstrato Único (SAM Interfaces) .
Interfaces Funcionais são a base para expressões Lambda e permitem escrever código conciso e expressivo, removendo a necessidade de classes internas anônimas.
O Java 8 fornece várias interfaces funcionais integradas, algumas delas são Predicate , Function , Consumer e Supplier .
Você pode consultar o exemplo simples acima, onde definimos uma interface funcional MaxFinder .
A anotação @FunctionalInterface é usada para representar uma interface funcional.
(i) Predicado
A interface de predicado possui um único método abstrato test(T t) que recebe um único argumento e retorna um valor booleano .
Geralmente é usado para filtrar valores ou para testar se um valor satisfaz uma condição.
T : tipo do argumento de entrada do método
Aqui está um exemplo usando predicado :
Predicate<Integer> isEligibleForVoting = (age) -> age >= 18;
boolean eligible = isEligibleForVoting.test(22); // true
A interface da função tem um único método abstrato apply(T t) que recebe um único argumento e retorna um objeto .
Geralmente é usado para transformar ou mapear valores de um tipo para outro.
Aqui está um exemplo usando Function :
Function<Integer, Integer> findSquare = (num) -> (num*num);
int square = findSquare.apply(5); // 25
A interface do consumidor tem um único método abstrato accept(T t) que recebe um único argumento e não retorna nenhum resultado .
Geralmente é usado para executar efeitos colaterais como impressão ou registro .
Aqui está um exemplo usando Consumer :
Consumer<String> printValue = (x) -> System.out.println(x);
printValue.accept("Java 8 features!"); // prints "Java 8 features!"
A interface do fornecedor tem um único método abstrato get() que não aceita nenhum argumento e retorna um resultado .
Geralmente é usado para inicialização preguiçosa ou para gerar valores aleatórios.
Aqui está um exemplo usando Fornecedor:
Supplier<Integer> getRandomInteger = () -> (int) (Math.random() * 500);
int randomInteger = getRandomInteger.get(); // random integer between 0 and 500
public class FunctionalInterfacesExample {
public static void main(String[] args) {
// Using Predicate functional interface
Predicate<Integer> isEligibleForVoting = (age) -> age >= 18;
boolean eligible = isEligibleForVoting.test(22); // true
System.out.println(String.format("Eligible for voting: %s", eligible));
// Using Function functional interface
Function<Integer, Integer> findSquare = (num) -> (num * num);
int square = findSquare.apply(5); // 25
System.out.println(String.format("Square of 5: %s", square));
// Using Consumer functional interface
Consumer<String> printValue = (val) -> System.out.println(val);
printValue.accept("Java 8 features!"); // prints "Java 8 features!"
// Using Supplier functional interface
Supplier<Integer> getRandomInteger = () -> (int) (Math.random() * 500);
int randomInteger = getRandomInteger.get(); // random integer between 0 and 500
System.out.println(String.format("Random number: %s", randomInteger));
}
}
3. API de transmissão
Java 8 Stream API é uma ferramenta poderosa para processar coleções de dados.
Usando a Stream API, tarefas complexas de manipulação de dados podem ser executadas de maneira mais concisa e expressiva do que com instruções condicionais e loops tradicionais.
Um Stream é uma sequência ordenada de elementos que podem ser processados sequencialmente ou paralelamente .
Com a ajuda de interfaces e métodos funcionais, podemos criar , transformar e processar fluxos.
O fluxo de uma coleção pode ser criado usando o método stream() .
A API Streams é uma nova adição ao Java Collections Framework que fornece uma maneira declarativa de processar coleções de objetos. Os fluxos permitem que você execute várias operações, como filtragem , mapeamento e redução em coleções de objetos de maneira mais concisa e legível do que os loops for tradicionais.
A API Stream consiste em três tipos de operações:
(i) Operações intermediárias:
As operações intermediárias são usadas para transformar ou filtrar os elementos de um fluxo.
Eles retornam um novo fluxo que pode ser processado por operações intermediárias ou terminais .
As operações intermediárias usadas com mais frequência são:
- filter() : usado para filtrar valores com base em uma condição
- sorted() : usado para ordenar elementos
- distinto () : usado para encontrar elementos distintos
- map() : usado para mapear o valor de um tipo para outro
As operações de terminal são usadas para produzir um resultado final de um fluxo.
Eles são chamados após todas as operações intermediárias que foram aplicadas ao fluxo.
As operações de terminal usadas com mais frequência são:
- collect() : usado para retornar o resultado das operações intermediárias
- reduce() : usado para reduzir os elementos de um stream em um único elemento.
- forEach() : usado para percorrer cada elemento no fluxo
- count() : retorna a contagem de elementos neste stream
As operações de curto-circuito são usadas para produzir um resultado antecipadamente, sem processar todo o fluxo.
Operações intermediárias e terminais de fluxo do Java 8 podem estar em curto-circuito.
As operações de terminal usadas com mais frequência são:
- limit () : usado para retornar o fluxo assim que atingir o valor limite fornecido
- anyMatch() : usado para verificar se algum elemento deste fluxo corresponde ao predicado fornecido.
- findFirst() : retorna um Optional descrevendo o primeiro elemento do stream, ou um Optional vazio se o stream estiver vazio
- findAny() : retorna um Optional descrevendo algum elemento do stream, ou um Optional vazio se o stream estiver vazio.
public class StreamAPIExample {
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(3, 1, 4, 2, 6, 8, 5, 7);
System.out.print("Given numbers list: ");
nums.forEach(num -> System.out.print(String.format("%s, ", num)));
System.out.println();
// sort list of numbers
List<Integer> sortedNums = nums.stream().sorted().collect(Collectors.toList());
System.out.print("Sorted numbers are: ");
sortedNums.forEach(num -> System.out.print(String.format("%s, ", num)));
System.out.println();
// filter all numbers less than 6
List<Integer> filteredNums = nums.stream()
.filter(i -> i < 6)
.collect(Collectors.toList());
System.out.print("Numbers less then 5 are: ");
filteredNums.forEach(num -> System.out.print(String.format("%s, ", num)));
System.out.println();
// odd numbers
long oddNumsCount = nums.stream()
.filter(i -> i % 2 == 1).count();
System.out.println(String.format("Total odd numbers are: %s", oddNumsCount));
// print first 2 even numbers found from list while iterating stream
System.out.print("first 2 even numbers found from list while iterating stream: ");
nums.stream()
.filter(num -> num % 2 == 0)
.limit(2)
.forEach(num -> System.out.print(String.format("%s, ", num)));
System.out.println();
// find squares of numbers
List<Integer> squares = nums.stream()
.map(num -> (num * num))
.collect(Collectors.toList());
System.out.print("Squares of numbers are: ");
squares.forEach(square -> System.out.print(String.format("%s, ", square)));
}
}
Obrigado por ler, espero que esta história tenha ajudado você a aprender os recursos do Java 8.
Por favor, siga se você gosta do artigo.
Inscreva-se para ficar atento aos próximos artigos.





































![O que é uma lista vinculada, afinal? [Parte 1]](https://post.nghiatu.com/assets/images/m/max/724/1*Xokk6XOjWyIGCBujkJsCzQ.jpeg)