Menu

Arrays em Java 8 - Stream Class e método ParallelSort

arrays java 8 stream class

Experimente Nosso Instrumento Para Eliminar Problemas

Java 8 foi uma versão importante na história do Java. Este tutorial explica várias mudanças em matrizes em Java 8, como classe de streams e classificação paralela:

Muitos novos recursos foram introduzidos nesta versão, conforme já discutido em nosso tutorial anterior sobre “Recursos do Java 8”. Vamos aprender sobre Java 8 Stream Class e Parallel Sorting Method.

=> Veja a série de treinamento simples em Java aqui.

Arrays em Java 8

O que você aprenderá:

Arrays em Java 8

Java8 introduziu alguns recursos especificamente relacionados a arrays.

Inclui:

  • Streams para matrizes
  • Classificação Paralela

Neste tutorial, discutiremos esses dois recursos do Java 8 em detalhes.

Java 8 Stream

Java 8 adicionou uma classe de fluxo para arrays que melhora a legibilidade, bem como a eficiência dos arrays. A conversão de matrizes em fluxo também aumenta o desempenho geral do programa.

Além disso, você também pode usar os vários métodos de API de fluxo que podem simplificar o mapeamento e ações de filtragem em matrizes.

As sobrecargas de método a seguir podem ser usadas para converter uma matriz em um fluxo .

Stream stream(T() array) IntStream stream(int() array) LongStream stream(long() array) DoubleStream stream(double() array)

O programa a seguir mostra a implementação do uso de fluxos com matrizes. Este programa mostra uma comparação entre a abordagem Iterativa e a abordagem Streams. Posteriormente, a soma dos elementos no array é calculada usando Iteration e Streams e a média é calculada.

import java.util.Arrays; class Main { public static void main(String() args) { int intArray() = {5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100}; //calculate sum using iterative method int sum = 0; for (int i = 0; i System.out.print(e + ' ')); } }

Resultado:

Implementação do uso de streams com arrays

A saída acima mostra a iteração média e abordagem de fluxos. Como os elementos são menos, a média é a mesma, mas à medida que os elementos no array aumentam, a abordagem iterativa se torna mais lenta.

O próximo exemplo de programação mostra como uma matriz é convertida em fluxo inteiro e, em seguida, usando o método map do fluxo para mapear elementos da matriz para valores aleatórios e, em seguida, adicionar esses elementos. O programa então imprime a soma de todos os elementos no fluxo de inteiros .

import java.util.Arrays; class Main { public static void main(String() args) { //declare array of ints int() ints = new int(100); //fill array with value 10 Arrays.fill(ints, 10); //maps array stream to random numbers and calculates sum of the elements int sum = Arrays.stream(ints) .map(i -> (int) (Math.random() * i)) .sum(); //print the sum System.out.println('The sum of the random array elements: ' + sum); } }

Resultado:

Imprime a soma de todos os elementos no fluxo de inteiros

Usamos o método map fornecido pela classe Stream no programa acima. Também usamos o método sum () que adiciona os elementos no fluxo.

como reverter um array em java

Método Java 8 parallelSort ()

O método “parallelSort ()” é introduzido no Java 8. É um método da classe java.util.Arrays. O método parallelSort é usado para classificar uma matriz em paralelo. Ele usa a abordagem bifurcação e junção, na qual as matrizes são divididas em unidades menores até que cada unidade seja facilmente gerenciável e, em seguida, classificada individualmente.

Em seguida, as unidades menores são unidas e toda essa operação acontece em paralelo. Uma vantagem principal desse método parallelSort é que ele usa multithreading, tornando a classificação mais rápida e eficiente.

O método parallelSort () tem as seguintes sobrecargas:

public static void parallelSort (Object obj())

O protótipo do método acima é usado para classificar uma matriz em ordem crescente.

public static void parallelSort (Object obj(), int fromIndex, int toIndex)

A sobrecarga acima é usada para classificar elementos no intervalo especificado de ‘fromIndex’ a ‘toIndex’ na matriz.

O programa Java a seguir demonstra o método parallelSort para classificar uma matriz.

import java.util.Arrays; public class Main { public static void main(String() args) { // Creating an array int numArray() = { 54,34,25,13,65,37,85,47,26 }; // print the original Array System.out.print('Original Unsorted Array: '); // iterate the array using streams Arrays.stream(numArray) .forEach(num ->System.out.print(num + ' ')); System.out.println(); // Using parallelSort() method to sort array Arrays.parallelSort(numArray); // Print sorted Array System.out.print('Array sorted using parallelSort: '); Arrays.stream(numArray) .forEach(num->System.out.print(num + ' ')); } }

Resultado:

Método parallelSort para classificar uma matriz

No programa acima, a matriz de entrada é classificada usando um método parallelSort e a saída é impressa.

O próximo programa compara os dois métodos de classificação fornecidos pela classe Arrays, ou seja, o método sort () que é uma classificação linear e o método parallelSort (). Este programa compara o tempo gasto por cada método para classificar uma matriz . O tempo é calculado para cada iteração.

import java.util.Arrays; import java.util.Random; public class Main { public static void main(String() args) { // Create an array int numArray() = new int(100); System.out.println('Iteration#' + ' ' + 'Serial Sort :Time(in ns)' + ' ' + 'Parallel Sort :Time(in ns)'); // Iterating Loop till i = 1000 // with interval of 10 for (int i = 0; i <100; i += 10) { System.out.print(' ' + (i / 10 + 1) + ' '); // Array generation using random function Random rand = new Random(); for (int j = 0; j < 100; j++) { numArray(j) = rand.nextInt(); } // Arrays.sort() method: Start and End Time long startTime = System.nanoTime(); // Call Serial Sort method Arrays.sort Arrays.sort(numArray); long endTime = System.nanoTime(); // Print Serial Sort results System.out.print((endTime - startTime) + ' '); // Arrays.parallelSort() start and end time startTime = System.nanoTime(); // call Parallel Sort method Arrays.parallelSort Arrays.parallelSort(numArray); endTime = System.nanoTime(); // Print Parallel Sort results System.out.println(' ' + (endTime - startTime)); System.out.println(); } } }

Resultado:

Compara o tempo gasto por cada método para classificar uma matriz

A saída acima mostra a comparação do tempo gasto pelos métodos sort e parallelSort para cada iteração. Você pode ver a diferença clara entre o desempenho dos métodos sort e parallelSort com a carenagem do método parallelSort muito melhor do que classificar.

perguntas frequentes

P # 1) O que é Arrays Stream em Java?

Responda: Este é o método stream da classe Arrays. Este método stream (array T ()) retorna um stream sequencial do array.

P # 2) O que é Stream () em Java?

Responda: Stream () em Java foi introduzido pela primeira vez em Java 8. A classe Stream consiste na API usada para processar objetos de coleção, incluindo matrizes.

P # 3) Como funciona o Java Stream?

Responda: As APIs de fluxo Java possuem um mecanismo que pode converter coleções como ArrayList, Arrays, etc. em fluxo. Eles também processam cada elemento desses fluxos em paralelo usando vários métodos fornecidos e passam os resultados.

P # 4) Qual é o propósito do método MAP do Stream em Java 8?

Responda: O método map pertence à classe java.util.stream.Streams. O método map aplica uma função a cada elemento de um fluxo ou mapeia para um valor diferente e o transforma.

P # 5) O Stream é mais rápido do que o loop Java?

Responda: Sim, especialmente os fluxos paralelos. Por exemplo, o método parallelSort da classe Arrays que usa fluxos paralelos é mais rápido do que o método de classificação sequencial fornecido pela classe Arrays.

Conclusão

Streams em Java é um novo recurso incluído desde Java 8. Streams fornece uma API de string cujos métodos podem ser usados ​​em coleções em Java. Neste tutorial, vimos métodos de fluxo que funcionam em arrays Java. Também vimos os outros recursos que foram adicionados aos arrays Java na edição Java 8.

Um deles é stream, enquanto o outro é o método parallelSort que classifica uma matriz de maneira paralela. Este método é mais rápido do que a ordenação por método linear, que ficou evidente no programa em que comparamos os dois métodos.

Leia também = >> Mudanças de interface em Java 8

=> Visite aqui a série exclusiva de tutoriais de treinamento em Java.

Leitura recomendada

^