Gamme en Java

En Java, la méthode Range est accessible dans les classes IntStream et LongStream. Dans la classe IntStream, cette méthode permet le retour de valeurs ordonnées séquentiellement dans la plage spécifiée en tant que paramètres de fonction. Les deux paramètres utilisés sont startInclusive (inclus) et endExclusive (exclusif), avec un pas incrémental. Il est important de noter que la valeur de départ est incluse tandis que la valeur de fin est exclue. La classe LongStream suit un modèle similaire, la seule distinction étant l'inclusion des valeurs LongStream.

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

Syntaxe de plage en Java

Voyons la syntaxe de la méthode range en Java.

1. Syntaxe de la plage IntStream

static IntStream range(int startInclusive, int endExclusive)

Paramètres :

• IntStream : Il s'agit d'une séquence d'éléments de valeur int qui sont de type primitif.
• startInclusive : La plage inclut la valeur initiale.
• endExclusive : La dernière valeur ou limite supérieure exclue de la plage.

Valeur de retour : 

Cette méthode renvoie un IntStream séquentiel d'éléments int mentionnés dans la plage en tant que paramètres.

2. Syntaxe de la plage LongStream

static LongStream range(int startInclusive, int endExclusive)

Paramètres :

• LongStream : Il s'agit d'une séquence d'éléments à valeurs longues qui sont de type primitif.
• startInclusive : La plage inclut la valeur initiale.
• endExclusive : La dernière valeur ou limite supérieure exclue de la plage.

Valeur de retour : 

Cette méthode renvoie un LongStream séquentiel d'éléments longs mentionnés dans la plage en tant que paramètres.

Comment fonctionne la fonction Range en Java ?

Voyons d’abord comment fonctionne la gamme IntStream en Java. Semblable à d’autres classes en Java, cette classe nécessite également un package qui doit d’abord être importé. Pour travailler avec la classe IntStream, importez le package import java.util.stream.IntStream. Une fois importé, créez un IntStream pour que des éléments puissent y être ajoutés. Après avoir créé le flux, utilisez la méthode range() pour ajouter les éléments. L'exécution du code entraînera le retour d'un IntStream ordonné séquentiellement, avec un pas incrémentiel de un, dans la plage spécifiée fournie dans le paramètre.

Pour imprimer chaque élément, utilisez la méthode forEach comme indiqué ci-dessous.

intStream.forEach(System.out::println);

Dans le cas de LongStream, importez d'abord le package java.util.stream.LongStream. Semblable au fonctionnement d'IntStream, une fois le package importé, créez un LongStream afin que des éléments puissent y être ajoutés. Après avoir créé le flux, utilisez la méthode range() pour ajouter les éléments. L'exécution du code générera un LongStream ordonné séquentiellement dans la plage spécifiée, avec un pas incrémentiel de un.

Pour imprimer chaque élément, utilisez la méthode forEach, comme indiqué ci-dessous.

LongStream.forEach(System.out::println);

Une manière équivalente d'imprimer une séquence d'éléments croissants peut être générée séquentiellement à l'aide d'une boucle for, comme indiqué ci-dessous.

for (inti = startInclusive; i<endExclusive ; i++)
{... . . . }

Exemples de plage en Java

Voici les exemples :

Exemple n°1

Programme Java pour implémenter la fonction de plage IntStream.

Code :

// IntStream range implementation using Java
import java.util.*;
//import the package for IntStream
import java.util.stream.IntStream;
public class RangeExample {
// main method
public static void main(String[] args)
{
// Create an IntStream
IntStream st = IntStream.range(32, 45);
// Display the elements in the range mentioned as 32 and 45 where 32 is included and 45 is excluded
System.out.println("The elements are:");
st.forEach(System.out::println);
} }

Sortie :

Tout d’abord, importez le package java.util.stream.IntStream. Ensuite, créez un IntStream st pour y ajouter des éléments. Pour créer un IntStream ordonné séquentiellement de 32 à 44 (32 inclus, à l'exclusion de 45), utilisez la méthode range(32, 45) lors de la création du flux. L'exécution du code produira le résultat souhaité d'un IntStream ordonné séquentiellement allant de 32 à 44 avec un pas incrémentiel de un, comme indiqué dans l'exemple de sortie.

Exemple n°2

Programme Java pour implémenter la fonction de plage LongStream.

Code :

// LongStream range implementation using Java
import java.util.*;
//import the package for LongStream
import java.util.stream.LongStream;
public class RangeExample {
// main method
public static void main(String[] args)
{
// Create a LongStream
LongStream st = LongStream.range(1000001L, 1000010L);
// Display the elements in the range mentioned as 1000001L and 1000010L where 1000001L is included and 1000010L is excluded
System.out.println("The elements are:");
st.forEach(System.out::println);
} }

Sortie :

Comme le programme ci-dessus, importez le package java.util.stream.LongStream. Ensuite, créez un LongStreamst avec une plage de méthodes (100001L, 100010L) pour y ajouter des éléments. L'exécution du code générera un LongStream ordonné séquentiellement, qui s'étendra de 100001L à 100010L avec un pas incrémentiel de un. L'exemple de sortie démontrera ce comportement.

Exemple #3

Programme Java pour implémenter les fonctions de plage LongStream et IntStream en combinaison.

Code :

import java.util.*;
//import the package for IntStream
import java.util.stream.IntStream;
//import the package for LongStream
import java.util.stream.LongStream;
public class RangeExample {
// main method
public static void main(String[] args)
{
// Create an IntStream
IntStream str = IntStream.range(32, 45);
// Display the elements in the range mentioned as 32 and 45 where 32 is included and 45 is excluded
System.out.println("The IntStream elements are:");
str.forEach(System.out::println);
// Create a LongStream
LongStream st = LongStream.range(1000001L, 1000010L);
// Display the elements in the range mentioned as 1000001L and 1000010L where 1000001L is included and 1000010L is excluded
System.out.println("The LongStream elements are:");
st.forEach(System.out::println);
} }

Sortie :

Importez le package java.util.stream.IntStream et java.util.stream.LongStream. Ensuite, créez IntStreamstr et LongStreamst pour y ajouter des éléments. Pour créer un flux dans IntStream avec des éléments allant de 32 (inclus) à 45 (exclusif), vous pouvez utiliser la méthode range(32, 45). De même, utilisez la plage de méthodes (100001L, 100010L) pour ajouter des éléments dans LongStream. L'exécution du code produira un IntStream ordonné séquentiellement allant de 32 à 44 (32 inclus, à l'exclusion de 45). De plus, l'exécution du code renverra également un LongStream allant de 100001L à 100010L avec un pas incrémentiel de 1.

Conclusion

La méthode range en Java renvoie les valeurs IntStream et LongStream ordonnées séquentiellement dans la plage mentionnée comme paramètres de fonction. Dans cet article, plusieurs aspects de celui-ci sont abordés en détail.

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!