Java 8 - Fluxos
Stream é uma nova camada abstrata introduzida no Java 8. Usando stream, você pode processar dados de maneira declarativa semelhante a instruções SQL. Por exemplo, considere a seguinte instrução SQL.
SELECT max(salary), employee_id, employee_name FROM Employee
A expressão SQL acima retorna automaticamente os detalhes do funcionário assalariado máximo, sem fazer nenhum cálculo por parte do desenvolvedor. Usando o framework de coleções em Java, um desenvolvedor precisa usar loops e fazer verificações repetidas. Outra preocupação é a eficiência; como os processadores multi-core estão disponíveis com facilidade, um desenvolvedor Java precisa escrever um processamento de código paralelo que pode ser bastante propenso a erros.
Para resolver esses problemas, o Java 8 introduziu o conceito de fluxo que permite ao desenvolvedor processar dados de forma declarativa e alavancar a arquitetura multicore sem a necessidade de escrever nenhum código específico para ela.
O que é transmissão?
Stream representa uma sequência de objetos de uma fonte, que oferece suporte a operações agregadas. A seguir estão as características de um Stream -
-
Sequência de elementos − Um fluxo fornece um conjunto de elementos de tipo específico de forma sequencial. Um fluxo obtém/computa elementos sob demanda. Ele nunca armazena os elementos.
-
Fonte − Stream usa recursos de coleções, matrizes ou E/S como fonte de entrada.
-
Operações agregadas − O Stream suporta operações agregadas como filtrar, mapear, limitar, reduzir, localizar, corresponder e assim por diante.
-
Encanamento − A maioria das operações de stream retorna o próprio stream para que seu resultado possa ser canalizado. Essas operações são chamadas de operações intermediárias e sua função é receber a entrada, processá-la e retornar a saída ao destino. O método collect() é uma operação de terminal que normalmente está presente no final da operação de pipeline para marcar o final do fluxo.
-
Iterações automáticas − As operações de fluxo fazem as iterações internamente sobre os elementos de origem fornecidos, em contraste com as Coleções onde a iteração explícita é necessária.
Gerando fluxos
Com Java 8, a interface Collection possui dois métodos para gerar um Stream.
-
fluxo() − Retorna um fluxo sequencial considerando a coleção como sua fonte.
-
parallelStream() − Retorna um Stream paralelo considerando a coleção como sua fonte.
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
forEach
Stream forneceu um novo método 'forEach' para iterar cada elemento do fluxo. O segmento de código a seguir mostra como imprimir 10 números aleatórios usando forEach.
Random random = new Random(); random.ints().limit(10).forEach(System.out::println);
mapa
O método ‘map’ é usado para mapear cada elemento ao seu resultado correspondente. O segmento de código a seguir imprime quadrados exclusivos de números usando map.
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); //get list of unique squares List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
filtro
O método de 'filtro' é usado para eliminar elementos com base em um critério. O segmento de código a seguir imprime uma contagem de strings vazias usando filter.
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//get count of empty string
int count = strings.stream().filter(string -> string.isEmpty()).count();
limite
O método 'limit' é usado para reduzir o tamanho do fluxo. O segmento de código a seguir mostra como imprimir 10 números aleatórios usando limite.
Random random = new Random(); random.ints().limit(10).forEach(System.out::println);
classificado
O método 'classificado' é usado para classificar o fluxo. O segmento de código a seguir mostra como imprimir 10 números aleatórios em uma ordem de classificação.
Random random = new Random(); random.ints().limit(10).sorted().forEach(System.out::println);
Processamento paralelo
parallelStream é a alternativa de stream para processamento paralelo. Dê uma olhada no seguinte segmento de código que imprime uma contagem de strings vazias usando parallelStream.
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
//get count of empty string
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();
É muito fácil alternar entre fluxos sequenciais e paralelos.
Colecionadores
Os coletores são usados para combinar o resultado do processamento nos elementos de um fluxo. Os coletores podem ser usados para retornar uma lista ou uma string.
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("Filtered List: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("Merged String: " + mergedString);
Estatísticas
Com o Java 8, os coletores de estatísticas são introduzidos para calcular todas as estatísticas quando o processamento de fluxo está sendo feito.
List numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("Highest number in List : " + stats.getMax());
System.out.println("Lowest number in List : " + stats.getMin());
System.out.println("Sum of all numbers : " + stats.getSum());
System.out.println("Average of all numbers : " + stats.getAverage());
Exemplo de fluxo
Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C:\> JAVA.
Java8Tester.java
Demonstração ao vivo
import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.Map;
public class Java8Tester {
public static void main(String args[]) {
System.out.println("Using Java 7: ");
// Count empty strings
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
System.out.println("List: " +strings);
long count = getCountEmptyStringUsingJava7(strings);
System.out.println("Empty Strings: " + count);
count = getCountLength3UsingJava7(strings);
System.out.println("Strings of length 3: " + count);
//Eliminate empty string
List<String> filtered = deleteEmptyStringsUsingJava7(strings);
System.out.println("Filtered List: " + filtered);
//Eliminate empty string and join using comma.
String mergedString = getMergedStringUsingJava7(strings,", ");
System.out.println("Merged String: " + mergedString);
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
//get list of square of distinct numbers
List<Integer> squaresList = getSquares(numbers);
System.out.println("Squares List: " + squaresList);
List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
System.out.println("List: " +integers);
System.out.println("Highest number in List : " + getMax(integers));
System.out.println("Lowest number in List : " + getMin(integers));
System.out.println("Sum of all numbers : " + getSum(integers));
System.out.println("Average of all numbers : " + getAverage(integers));
System.out.println("Random Numbers: ");
//print ten random numbers
Random random = new Random();
for(int i = 0; i < 10; i++) {
System.out.println(random.nextInt());
}
System.out.println("Using Java 8: ");
System.out.println("List: " +strings);
count = strings.stream().filter(string->string.isEmpty()).count();
System.out.println("Empty Strings: " + count);
count = strings.stream().filter(string -> string.length() == 3).count();
System.out.println("Strings of length 3: " + count);
filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
System.out.println("Filtered List: " + filtered);
mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("Merged String: " + mergedString);
squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
System.out.println("Squares List: " + squaresList);
System.out.println("List: " +integers);
IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
System.out.println("Highest number in List : " + stats.getMax());
System.out.println("Lowest number in List : " + stats.getMin());
System.out.println("Sum of all numbers : " + stats.getSum());
System.out.println("Average of all numbers : " + stats.getAverage());
System.out.println("Random Numbers: ");
random.ints().limit(10).sorted().forEach(System.out::println);
//parallel processing
count = strings.parallelStream().filter(string -> string.isEmpty()).count();
System.out.println("Empty Strings: " + count);
}
private static int getCountEmptyStringUsingJava7(List<String> strings) {
int count = 0;
for(String string: strings) {
if(string.isEmpty()) {
count++;
}
}
return count;
}
private static int getCountLength3UsingJava7(List<String> strings) {
int count = 0;
for(String string: strings) {
if(string.length() == 3) {
count++;
}
}
return count;
}
private static List<String> deleteEmptyStringsUsingJava7(List<String> strings) {
List<String> filteredList = new ArrayList<String>();
for(String string: strings) {
if(!string.isEmpty()) {
filteredList.add(string);
}
}
return filteredList;
}
private static String getMergedStringUsingJava7(List<String> strings, String separator) {
StringBuilder stringBuilder = new StringBuilder();
for(String string: strings) {
if(!string.isEmpty()) {
stringBuilder.append(string);
stringBuilder.append(separator);
}
}
String mergedString = stringBuilder.toString();
return mergedString.substring(0, mergedString.length()-2);
}
private static List<Integer> getSquares(List<Integer> numbers) {
List<Integer> squaresList = new ArrayList<Integer>();
for(Integer number: numbers) {
Integer square = new Integer(number.intValue() * number.intValue());
if(!squaresList.contains(square)) {
squaresList.add(square);
}
}
return squaresList;
}
private static int getMax(List<Integer> numbers) {
int max = numbers.get(0);
for(int i = 1;i < numbers.size();i++) {
Integer number = numbers.get(i);
if(number.intValue() > max) {
max = number.intValue();
}
}
return max;
}
private static int getMin(List<Integer> numbers) {
int min = numbers.get(0);
for(int i= 1;i < numbers.size();i++) {
Integer number = numbers.get(i);
if(number.intValue() < min) {
min = number.intValue();
}
}
return min;
}
private static int getSum(List numbers) {
int sum = (int)(numbers.get(0));
for(int i = 1;i < numbers.size();i++) {
sum += (int)numbers.get(i);
}
return sum;
}
private static int getAverage(List<Integer> numbers) {
return getSum(numbers) / numbers.size();
}
}
Verifique o resultado
Compile a classe usando javac compilador da seguinte forma -
C:\JAVA>javac Java8Tester.java
Agora execute o Java8Tester da seguinte forma -
C:\JAVA>java Java8Tester
Deve produzir o seguinte resultado -
Using Java 7: List: [abc, , bc, efg, abcd, , jkl] Empty Strings: 2 Strings of length 3: 3 Filtered List: [abc, bc, efg, abcd, jkl] Merged String: abc, bc, efg, abcd, jkl Squares List: [9, 4, 49, 25] List: [1, 2, 13, 4, 15, 6, 17, 8, 19] Highest number in List : 19 Lowest number in List : 1 Sum of all numbers : 85 Average of all numbers : 9 Random Numbers: -1279735475 903418352 -1133928044 -1571118911 628530462 18407523 -881538250 -718932165 270259229 421676854 Using Java 8: List: [abc, , bc, efg, abcd, , jkl] Empty Strings: 2 Strings of length 3: 3 Filtered List: [abc, bc, efg, abcd, jkl] Merged String: abc, bc, efg, abcd, jkl Squares List: [9, 4, 49, 25] List: [1, 2, 13, 4, 15, 6, 17, 8, 19] Highest number in List : 19 Lowest number in List : 1 Sum of all numbers : 85 Average of all numbers : 9.444444444444445 Random Numbers: -1009474951 -551240647 -2484714 181614550 933444268 1227850416 1579250773 1627454872 1683033687 1798939493 Empty Strings: 2
Java