Comment utiliser la fonction Range en Java
Préface
En Java, la méthode Range est disponible dans les classes IntStream et LongStream. Dans la classe IntStream, il est utile de renvoyer la valeur séquentielle de IntStream dans la portée du paramètre de fonction. Dans cette méthode, startInclusive(inclusive)
et endExclusive(exclusive)
sont les deux paramètres utilisés avec la taille du pas d'incrémentation, qui, comme mentionné précédemment, inclura la valeur de départ. , à l'exclusion de la valeur finale. Dans le cas de LongStream, la seule différence est l'ajout de la valeur LongStream. startInclusive(inclusive)
和endExclusive(exclusive)
是与增量步长一起使用的两个参数,如前所述,将包括起始值,并排除结束值。在LongStream的情况下,唯一的区别是添加了LongStream值。
Range语法
让我们看看Java中range方法的语法。
IntStream范围的语法
static IntStream range(int startInclusive, int endExclusive)
参数:
IntStream:这是一个原始类型的int值元素序列。
startInclusive:包含在范围中的初始值。
endExclusive:在范围内排除的最后一个值或上限。
返回值:
该方法返回范围中提到的int元素的连续int流作为参数。
LongStream范围的语法
static LongStream range(int startInclusive, int endExclusive)
参数:
LongStream:这是一个基元类型的长值元素序列。
startInclusive:包含在范围中的初始值。
endExclusive:在范围内排除的最后一个值或上限。
返回值:
该方法返回范围中提到的长元素的连续长流作为参数。
Range函数在Java中是如何工作的?
首先,让我们看看IntStream范围在Java中是如何工作的。与Java中的其他类类似,这个类也需要一个必须首先导入的包。也就是说,为了使用IntStream类,导入包java.util.stream.IntStream
。导入后,创建一个IntStream,以便可以向其中添加元素。创建流后,使用方法range()
添加元素。在执行代码时,将通过在参数中提到的范围内的一个增量步骤返回一个序列有序IntStream。
要打印每个元素,请使用如下所示的方法。
intStream.forEach(System.out::println);
对于LongStream,首先导入包java.util.stream.LongStream
。与IntStream的功能类似,一旦导入包,就创建一个LongStream,以便可以向其中添加元素。创建流后,使用方法range()添加元素。在执行代码时,将通过在参数中提到的范围内的一个增量步骤返回序列有序的长流。
用于使用如下所示的方法打印每个元素。
LongStream.forEach(System.out::println);
在for循环的帮助下,可以按顺序生成递增元素的等效打印序列,
如下所示:
for (inti = startInclusive; i<endExclusive ; i++) {... . . . }
Java中的Range示例
以下是提到的示例:
示例#1
Java程序实现IntStream Range函数。
代码:
// 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); } }
输出:
首先,导入包java.util.stream.IntStream
。然后,创建一个IntStream st
,用于向其中添加元素。在创建流的过程中,使用方法range(32,45)添加元素,其中包括32个元素,排除45个元素。在执行代码时,将通过一个增量步骤从32到44返回一个有序的IntStream,如示例输出中所示。
示例#2
Java程序实现LongStream range范围函数。
代码:
// 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); } }
输出:
与上述程序类似,导入包java.util.stream.LongStream
。然后,创建一个具有方法range(100001L、100010L)
的LongStreamst,用于向其添加元素。在执行代码时,将通过一个增量步骤从100001L返回到100010L,如示例输出所示。
示例#3
Java程序,用于组合实现LongStream和IntStream range范围函数。
代码:
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); } }
输出:
导入包java.util.stream.IntStream
和 java.util.stream.LongStream
。然后,创建IntStreamstr和LongStreamst以向其中添加元素。在创建流期间,使用方法range(32,45)
在IntStream中添加元素,其中包括32,排除45。同样,使用方法range(100001L、100010L)
Syntaxe pour la plage IntStream
rrreee🎜Paramètres :🎜- 🎜IntStream : Il s'agit d'une valeur int de type primitif Séquence d'éléments. 🎜
- 🎜startInclusive : La valeur initiale incluse dans la plage. 🎜
- 🎜endExclusive : La dernière valeur ou limite supérieure à exclure dans la plage. 🎜 🎜🎜Valeur de retour :🎜🎜Cette méthode renvoie un flux int continu d'éléments int mentionnés dans la plage en tant que paramètre. 🎜
- 🎜LongStream :c'est une séquence d'éléments à valeurs longues de type primitif. 🎜
- 🎜startInclusive : La valeur initiale incluse dans la plage. 🎜
- 🎜endExclusive : La dernière valeur ou limite supérieure à exclure dans la plage. 🎜 🎜🎜Valeur de retour :🎜🎜Cette méthode renvoie un long flux continu d'éléments longs mentionnés dans la plage en tant que paramètre. 🎜🎜Comment fonctionne la fonction Range en Java ? 🎜🎜Tout d’abord, voyons comment fonctionne la portée IntStream en Java. Semblable à d'autres classes en Java, cette classe nécessite également un package qui doit être importé en premier. Autrement dit, pour utiliser la classe IntStream, importez le package
Syntaxe de la plage LongStream
rrreee🎜Paramètres :🎜java.util.stream.IntStream
. Après l'importation, créez un IntStream afin de pouvoir y ajouter des éléments. Après avoir créé le flux, utilisez la méthode range()
pour ajouter des éléments. Lorsque le code est exécuté, une séquence de IntStreams ordonnés sera renvoyée par une étape incrémentielle dans la plage mentionnée dans le paramètre. 🎜🎜Pour imprimer chaque élément, utilisez la méthode indiquée ci-dessous. 🎜rrreee🎜Pour LongStream, importez d'abord le package java.util.stream.LongStream
. Semblable à la fonctionnalité d'IntStream, une fois le package importé, un LongStream est créé afin que des éléments puissent y être ajoutés. Après avoir créé le flux, ajoutez des éléments à l'aide de la méthode range(). Lorsque le code est exécuté, un long flux d'ordre de séquence sera renvoyé par une étape incrémentielle dans la plage mentionnée dans le paramètre. 🎜🎜 est utilisé pour imprimer chaque élément en utilisant la méthode indiquée ci-dessous. 🎜rrreee🎜À l'aide de la boucle for, la séquence imprimée équivalente d'éléments croissants peut être générée séquentiellement, 🎜🎜comme indiqué ci-dessous :🎜rrreee🎜Exemple de plage en Java 🎜🎜Voici des exemples Mentionné :🎜🎜Exemple n°1🎜🎜Programme Java pour implémenter la fonction IntStream Range. 🎜🎜Code :🎜rrreee🎜Sortie :🎜🎜
java.util.stream.IntStream
. Ensuite, créez un IntStream st
auquel ajouter des éléments. Lors de la création du flux, la méthode range(32, 45) est utilisée pour ajouter des éléments, dont 32 éléments et excluant 45 éléments. Lorsque le code est exécuté, un IntStream ordonné sera renvoyé par une étape incrémentielle de 32 à 44, comme indiqué dans l'exemple de sortie. 🎜🎜Exemple n°2🎜🎜Le programme Java implémente la fonction de plage LongStream. 🎜🎜Code :🎜rrreee🎜Sortie :🎜🎜
java.util.stream.LongStream
. Ensuite, créez un LongStreamst avec la méthode range(100001L, 100010L)
pour y ajouter des éléments. Au fur et à mesure que le code est exécuté, il y aura un retour incrémentiel de 100001L à 100010L, comme indiqué dans l'exemple de sortie. 🎜🎜Exemple n°3🎜🎜Programme Java pour l'implémentation combinée des fonctions de plage LongStream et IntStream. 🎜🎜Code :🎜rrreee🎜Sortie :🎜🎜
java.util.stream.IntStream
et java.util.stream.LongStream
. Ensuite, créez un IntStreamstr et un LongStreamst auxquels ajouter des éléments. Lors de la création du flux, utilisez la méthode range(32, 45)
pour ajouter des éléments au IntStream incluant 32 et excluant 45. De même, utilisez la méthode range(100001L, 100010L)
pour ajouter des éléments dans le LongStream. Lorsque le code est exécuté, le IntStream séquencé reviendra de 32 à 44 et le LongStream reviendra de 100001L à 100010L avec un pas incrémentiel de 1. 🎜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!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Guide du nombre parfait en Java. Nous discutons ici de la définition, comment vérifier le nombre parfait en Java ?, des exemples d'implémentation de code.

Guide du générateur de nombres aléatoires en Java. Nous discutons ici des fonctions en Java avec des exemples et de deux générateurs différents avec d'autres exemples.

Guide de Weka en Java. Nous discutons ici de l'introduction, de la façon d'utiliser Weka Java, du type de plate-forme et des avantages avec des exemples.

Guide du nombre de Smith en Java. Nous discutons ici de la définition, comment vérifier le numéro Smith en Java ? exemple avec implémentation de code.

Dans cet article, nous avons conservé les questions d'entretien Java Spring les plus posées avec leurs réponses détaillées. Pour que vous puissiez réussir l'interview.

Java 8 présente l'API Stream, fournissant un moyen puissant et expressif de traiter les collections de données. Cependant, une question courante lors de l'utilisation du flux est: comment se casser ou revenir d'une opération FOREAK? Les boucles traditionnelles permettent une interruption ou un retour précoce, mais la méthode Foreach de Stream ne prend pas directement en charge cette méthode. Cet article expliquera les raisons et explorera des méthodes alternatives pour la mise en œuvre de terminaison prématurée dans les systèmes de traitement de flux. Lire plus approfondie: Améliorations de l'API Java Stream Comprendre le flux Forach La méthode foreach est une opération terminale qui effectue une opération sur chaque élément du flux. Son intention de conception est

Guide de TimeStamp to Date en Java. Ici, nous discutons également de l'introduction et de la façon de convertir l'horodatage en date en Java avec des exemples.

Java est un langage de programmation populaire qui peut être appris aussi bien par les développeurs débutants que par les développeurs expérimentés. Ce didacticiel commence par les concepts de base et progresse vers des sujets avancés. Après avoir installé le kit de développement Java, vous pouvez vous entraîner à la programmation en créant un simple programme « Hello, World ! ». Une fois que vous avez compris le code, utilisez l'invite de commande pour compiler et exécuter le programme, et « Hello, World ! » s'affichera sur la console. L'apprentissage de Java commence votre parcours de programmation et, à mesure que votre maîtrise s'approfondit, vous pouvez créer des applications plus complexes.
