Meny

Arrays In Java 8 - Stream Class And ParallelSort Method

  • Hoved
  • Annen
  • Arrays In Java 8 - Stream Class And ParallelSort Method

arrays java 8 stream class

Prøv Instrumentet Vårt For Å Eliminere Problemer

Java 8 har vært en stor utgivelse i Java-historien. Denne opplæringen forklarer forskjellige endringer i matriser i Java 8 som strømmer klasse og parallell sortering:

Mange nye funksjoner ble introdusert i denne utgivelsen som allerede diskutert i vår forrige opplæring om “Java 8-funksjoner”. La oss lære om Java 8 Stream Class og parallell sorteringsmetode.

=> Se opp den enkle Java-treningsserien her.

Arrays i Java 8

Hva du vil lære:

Matriser i Java 8

Java8 introduserte noen få funksjoner som er spesielt relatert til matriser.

Det inkluderer:

  • Strømmer for arrays
  • Parallell sortering

I denne opplæringen vil vi diskutere disse to funksjonene i Java 8 i detalj.

Java 8 Stream

Java 8 har lagt til en strømklasse for matriser som forbedrer lesbarheten og effektiviteten til matriser. Konvertering av arrays for å streame øker også den totale ytelsen til programmet.

I tillegg til dette kan du også bruke de forskjellige Stream API-metodene som kan forenkle kartlegging og filtrering av arrays.

Følgende metodeoverbelastning kan brukes til å konvertere en matrise til en strøm .

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

Følgende program viser implementeringen av bruk av strømmer med matriser. Dette programmet viser en sammenligning av Iterativ tilnærming og Streams-tilnærming. Senere beregnes summen av elementene i matrisen ved hjelp av Iteration og Streams, og gjennomsnittet beregnes.

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 + ' ')); } }

Produksjon:

Implementering av bruk av strømmer med matriser

Ovennevnte utgang viser gjennomsnittlig iterasjon og strømmer tilnærming. Siden elementene er mindre, er gjennomsnittet det samme, men når elementene i matrisen øker, blir den iterative tilnærmingen tregere.

Det neste programmeringseksemplet viser hvordan en matrise konverteres til heltallstrøm, og deretter bruker kartmetoden til strømmen for å kartlegge elementer i matrisen til tilfeldige verdier, og deretter legge til disse elementene. Programmet da skriver ut summen av alle elementene i heltallstrømmen .

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); } }

Produksjon:

Skriver ut summen av alle elementene i heltallstrømmen

Vi har brukt kartmetoden som er gitt av Stream-klassen i programmet ovenfor. Vi brukte også sum () -metoden som legger til elementene i strømmen.

hva er en .bin fil?

Java 8 parallelSort () -metode

Metoden “parallelSort ()” ble introdusert i Java 8. Det er en metode for klassen java.util.Arrays. ParallellSort-metoden brukes til å sortere en matrise parallelt. Den bruker tilnærmingen med gaffel og sammenføyning der matriser gaffles i mindre enheter til hver enhet er lett å håndtere og deretter sorteres individuelt.

Deretter blir de mindre enhetene koblet sammen, og hele denne operasjonen skjer parallelt. En hovedfordel med denne parallelSort-metoden er at den bruker multitrading og dermed gjør sortering raskere og effektiv.

Metoden parallelSort () har følgende overbelastninger:

public static void parallelSort (Object obj())

Ovennevnte metode prototype brukes til å sortere en matrise i stigende rekkefølge.

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

Ovennevnte overbelastning brukes til å sortere elementer i det angitte området fra 'fromIndex' til 'toIndex' i matrisen.

Følgende Java-program demonstrerer parallelSort-metoden for å sortere en matrise.

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 + ' ')); } }

Produksjon:

parallelSort-metode for å sortere en matrise

I det ovennevnte programmet sorteres inndata-arrayet ved hjelp av en parallelSort-metode og utskriften skrives ut.

Det neste programmet sammenligner de to sorteringsmetodene som tilbys av Arrays-klasse, dvs. sorteringsmetoden () som er en lineær sorterings- og parallelSort () -metode. Dette programmet sammenligner tiden det tar hver metode for å sortere en matrise . Tiden beregnes for hver iterasjon.

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(); } } }

Produksjon:

Sammenligner tiden det tar hver metode for å sortere en matrise

Ovennevnte utgang viser sammenligningen av tiden det tar med sorterings- og parallelSort-metodene for hver iterasjon. Du kan se den klare forskjellen mellom ytelsen til sort og parallelSort-metode med parallelSort-metoden som er mye bedre enn sort.

ofte stilte spørsmål

Q # 1) Hva er Arrays Stream i Java?

Svar: Dette er strømmetoden i Arrays-klassen. Denne metodestrømmen (T () -matrisen) returnerer en sekvensiell strøm fra matrisen.

Q # 2) Hva er Stream () i Java?

Svar: Stream () i Java ble først introdusert i Java 8. Stream-klasse består av API som brukes til å behandle samleobjekter inkludert matriser.

Spørsmål 3) Hvordan fungerer Java Stream?

Svar: API-ene til Java-strømmen har en mekanisme som kan konvertere samlinger som ArrayList, Arrays, etc. til å streame. De behandler også hvert element av disse strømningene parallelt ved hjelp av forskjellige metoder som er gitt, og gir resultater.

Q # 4) Hva er hensikten med MAP-metoden for Stream i Java 8?

Svar: Kartmetoden tilhører klassen java.util.stream.Streams. Kartmetoden bruker en funksjon til hvert element i en strøm eller tilordner den til en annen verdi og transformerer den.

Q # 5) Er Stream raskere enn for loop Java?

Svar: Ja, spesielt parallelle strømmer. For eksempel, parallelSort-metoden i Arrays-klassen som bruker parallelle strømmer er raskere enn den sekvensielle sorteringsmetoden som tilbys av Arrays-klassen.

Konklusjon

Strømmer i Java er en ny funksjon som er inkludert siden Java 8. Strømmer gir en streng API hvis metoder kan brukes på samlinger i Java. I denne opplæringen har vi sett strømmetoder som fungerer på Java-arrays. Vi har også sett de andre funksjonene som ble lagt til Java-arrays i Java 8-utgaven.

En av dem er stream mens den andre er parallelSort-metoden som sorterer en matrise parallelt. Denne metoden er raskere enn den lineære metodesorten, noe som var tydelig i programmet der vi sammenlignet begge metodene.

Les også = >> Grensesnittendringer i Java 8

=> Besøk her for den eksklusive opplæringsserien for Java Training.

Anbefalt lesing

^