Flux parallèle Java

Un flux parallèle est un flux parallèle d'objets qui prend en charge diverses fonctions qui peuvent être destinées à produire le résultat attendu. Le flux parallèle n'est pas une structure de données qui permet à l'utilisateur de saisir des entrées à partir des collections, des tableaux, des API d'entrée et de sortie Java. Le flux parallèle ne modifie pas le comportement réel de la fonctionnalité, mais il peut fournir la sortie basée sur le filtre appliqué (pipeline). Le flux parallèle fait partie de la programmation fonctionnelle Java qui a vu le jour après la version Java 8^th. Le flux parallèle est un avantage supplémentaire pour les expressions Lambda.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Façons de créer un flux parallèle en Java

• Méthode parallelStream()
• méthode parallèle()

Comment fonctionne Parallel Stream en Java ?

Il est basé sur la méthode parallelStream() appliquée aux collections ou la méthode parallel() sur les flux.

Syntaxe :

List<Object> list=new ArrayList<Object>();
list.parallelStream();

Explication :

• Tout d'abord, nous créons une collection de listes de tableaux.
• Sur la collection de tableaux, méthode paralleStream() appliquée.
• Nous concluons que parallelStream() s'applique uniquement aux collections.

Syntaxe :

IntStream inStream=IntStream.rangeClosed(initialValue, finalValue);
inStream.parallel();

Explication :

• Tout d'abord, nous créons un flux IntStream.
• Méthode parallel() appliquée au flux.
• Nous concluons que parallel() s'applique uniquement aux flux.

Exemples

Vous trouverez ci-dessous les exemples :

Exemple n°1

parallelStream() appliqué aux alphabets majuscules.

Code :

import java.util.ArrayList;
import java.util.List;
public class ParalleStreamOnAlphabets {
public static void main(String[] args) {
System.out.println("Capital Alphabets before Parallel Stream");
// creating array list for adding alphabets
List<String> capitalAlphabets = new ArrayList<>();
int ascilCode = 65; // Ascii value of A=65 and Z=90
while (ascilCode <= 90) { // iterating ascii values
char alphabets = (char) ascilCode; // converting integer to character
capitalAlphabets.add(String.valueOf(alphabets)); // adding Capital alphabets to list
ascilCode++;// pre increment operator
}
// displaying initial Alphabets
capitalAlphabets.stream().forEach(System.out::println);
System.out.println("Capital Alphabets after Parallel Stream");
// inserting all elements to another list to apply parallelStream
// operation without modifying previous array list
List<String> captatlAlphabetsParalleStream = capitalAlphabets;
//applying parallelStream() on new array list
captatlAlphabetsParalleStream.parallelStream().forEach(System.out::println);
}
}

Sortie :

Explication :

• Comme vous pouvez voir la sortie avant d'appliquer le flux parallèle, nous avons obtenu la sortie séquentiellement.
• Mais lorsque nous avons appliqué le flux parallèle, nous avons obtenu une sortie en zigzag, ce qui signifie parallèlement.

Exemple n°2

parallelStream() appliqué aux nombres pairs.

Code :

import java.util.ArrayList;
import java.util.List;
public class ParallelStreamEvenNumbers {
public static void main(String[] args) {
System.out.println("Even Numbers before Parallel Stream");
// creating array list for adding alphabets
List<Integer> evenNumbers = new ArrayList<Integer>();
for (int number=0;number<=10;number++) { // iterating numbers
if(number%2==0) //if number even go inside the condition
evenNumbers.add(number); //added all even numbers
}
// displaying initial even numbers
evenNumbers.stream().forEach(System.out::println);
System.out.println("Even Numbers before Parallel Stream");
// inserting all elements to another list to apply parallelStream
// operation without modifying previous array list
List<Integer> captatlAlphabetsParalleStream = evenNumbers;
// applying parallelStream() on new array list
captatlAlphabetsParalleStream.parallelStream().forEach(System.out::println);
}
}

Sortie :

Explication :

• Comme vous pouvez voir la sortie avant d'appliquer le flux parallèle, nous avons obtenu la sortie séquentiellement.
• Mais lorsque nous avons appliqué le flux parallèle, nous avons obtenu une sortie en zigzag, ce qui signifie parallèlement.

Exemple #3

parallelStream() appliqué aux frais de cours.

Code :

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Stream;
public class ParallelStreamCourseFee {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("How many number would you like to enter=>");
int inputNumber = scanner.nextInt(); // asking user for number count
List<Courses> courseWithFee = new ArrayList<Courses>();// creating array
String coursename = "";
int courseFee = 0;
for (int i = 0; i < inputNumber; i++) {
coursename = scanner.next();//taking course name input
courseFee = scanner.nextInt();//taking course fee input
courseWithFee.add(new Courses(coursename, courseFee));//adding course name and fee
}
//get the stream list which courses fee is >1000
Stream<Courses> list = courseWithFee.parallelStream().filter(e -> e.getCourseFee() > 1000);
//displaying courses count which is fee is >1000
System.out.println("Course Fee above 1000 is=> " + list.count());
scanner.close();
}
}
//courses class
class Courses {
String course;
int courseFee;
public Courses(String course, int courseFee) {
this.course = course;
this.courseFee = courseFee;
}
public String getCourse() {
return course;
}
public void setCourse(String course) {
this.course = course;
}
public int getCourseFee() {
return courseFee;
}
public void setCourseFee(int courseFee) {
this.courseFee = courseFee;
}
}

Sortie :

Explication :

• Comme vous pouvez le voir dans le résultat, nous devons compter pour que les frais de cours soient>1000.

Exemple n°4

parallel() appliqué au nombre de nombres impairs.

Code :

import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
// Taking InStream with range of 1 to 1000
//On rane() applied parallel method
//On parallel() method applied filter to decide whether given number odd or not
//after getting odd numbers we simply displaying odd numnbers count
int oddNumberCount = (int) IntStream.range(1, 1000).parallel().filter(value -> oddOrNot(value)).count();
//displaying odd number count
System.out.println("Count of Odd Number from 1-1000 range is => " + oddNumberCount);
}
public static boolean oddOrNot(int inputNumber) {
//checking first number >0 and then checking range from 1 tom 1000
//next checking odd number or not within nonMatch method
return inputNumber > 0
&& IntStream.rangeClosed(1, inputNumber).noneMatch(temp -> inputNumber % 2 == 0);
}
}

Sortie :

Explication :

• Comme vous pouvez le voir, la méthode parallèle ne peut être appliquée qu'avec les flux.

Exemple #5

parallel() appliqué au nombre premier.

Code :

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.function.IntPredicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class ParallelPrimeNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("How many number would you like to enter=>");
int inputNumber = scanner.nextInt(); //asking user for number count
System.out.print("Enter your numbers =>");
List<Integer> listNumbers = new ArrayList<Integer>();//creating array list
for (int i = 0; i < inputNumber; i++) {
listNumbers.add(scanner.nextInt());//adding user elements into an array
}
//checking the entered numbers are prime or not
//filter(ParallelCount::isPrime) ParallelCount is class name and primeNumberOrNot method
List<Integer> primeOut = listNumbers.stream().filter(ParallelPrimeNumber::primeNumberOrNot).collect(Collectors.toList());
System.out.print("Prime number set from your entered numbers is/are=>");
for (Integer i : primeOut) {
System.out.print(i+" ");//displaying prime numbers
}
scanner.close();
}
public static boolean primeNumberOrNot(int i) {
//IntPredicate checks the number whether even, odd, prime etc. based on condition
IntPredicate trueOrNot = index -> i % index == 0;
//return true if entered number is prime else returns false
return i > 1 && IntStream.range(2, i).noneMatch(trueOrNot);
}
}

Sortie :

Explication :

• Comme vous pouvez le voir dans le code ci-dessus, même la méthode parallèle sur les flux exécute également la logique des nombres premiers, pairs, impairs, etc..

Avantages et applications de Java Parallel Stream

Vous trouverez ci-dessous les avantages et les applications :

Avantages

• Améliore l'utilisation du processeur plus efficacement que les filtres normaux.
• Le flux parallèle traite plusieurs données à la fois.

Applications

• Utilisé avec la fonctionnalité Agrégation.
• Utilisé avec des cadres de collection de plus grande taille.
• Utilisé avec des flux séquentiels.

Conclusion

Cela est réalisé avec la méthode parallelStream() sur les collections et la méthode parallel() sur les flux. Le flux parallèle réduit le temps de traitement, il utilise donc principalement des données de collecte volumineuses.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!