So verwenden Sie die Range-Funktion in Java

Vorwort

In Java ist die Range-Methode sowohl in der IntStream- als auch in der LongStream-Klasse verfügbar. In der IntStream-Klasse ist es hilfreich, den sequentiellen Wert von IntStream innerhalb des Funktionsparameterbereichs zurückzugeben. Bei dieser Methode sind startInclusive(inclusive) und endExclusive(exclusive) die beiden Parameter, die zusammen mit der Inkrementschrittgröße verwendet werden, die, wie bereits erwähnt, den Startwert einschließt und den Endwert ausschließen. Im Fall von LongStream besteht der einzige Unterschied in der Hinzufügung des LongStream-Werts. 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）

Range-Syntax🎜🎜Sehen wir uns die Syntax der Range-Methode in Java an. 🎜

Syntax für den IntStream-Bereich

rrreee🎜Parameter:🎜

• 🎜IntStream: Dies ist ein int-Wert vom primitiven Typ Reihenfolge der Elemente. 🎜
• 🎜startInclusive: Der im Bereich enthaltene Anfangswert. 🎜
• 🎜endExclusive: Der letzte Wert oder die Obergrenze, die im Bereich ausgeschlossen werden soll. 🎜
🎜🎜Rückgabewert:🎜🎜Diese Methode gibt einen kontinuierlichen int-Strom von int-Elementen zurück, die im Bereich als Parameter erwähnt werden. 🎜

LongStream-Bereichssyntax

rrreee🎜Parameter:🎜
• 🎜LongStream:das ist eine Folge langwertiger Elemente primitiven Typs. 🎜
• 🎜startInclusive:Der im Bereich enthaltene Anfangswert. 🎜
• 🎜endExclusive: Der letzte Wert oder die Obergrenze, die im Bereich ausgeschlossen werden soll. 🎜
🎜🎜Rückgabewert:🎜🎜Diese Methode gibt einen kontinuierlichen langen Strom langer Elemente zurück, die im Bereich als Parameter erwähnt werden. 🎜🎜Wie funktioniert die Range-Funktion in Java? 🎜🎜Sehen wir uns zunächst an, wie der IntStream-Bereich in Java funktioniert. Ähnlich wie andere Klassen in Java erfordert auch diese Klasse ein Paket, das zuerst importiert werden muss. Das heißt, um die IntStream-Klasse zu verwenden, importieren Sie das Paket java.util.stream.IntStream. Erstellen Sie nach dem Import einen IntStream, damit Sie ihm Elemente hinzufügen können. Verwenden Sie nach dem Erstellen des Streams die Methode range(), um Elemente hinzuzufügen. Wenn der Code ausgeführt wird, wird eine in IntStream geordnete Sequenz mit einem inkrementellen Schritt in dem im Parameter genannten Bereich zurückgegeben. 🎜🎜Um jedes Element zu drucken, verwenden Sie die unten gezeigte Methode. 🎜rrreee🎜Für LongStream importieren Sie zunächst das Paket java.util.stream.LongStream. Ähnlich wie bei der Funktionalität von IntStream wird nach dem Import des Pakets ein LongStream erstellt, sodass ihm Elemente hinzugefügt werden können. Fügen Sie nach dem Erstellen des Streams Elemente mit der Methode range() hinzu. Wenn der Code ausgeführt wird, wird ein langer Stream der Sequenzreihenfolge um einen inkrementellen Schritt in dem im Parameter genannten Bereich zurückgegeben. 🎜🎜 wird verwendet, um jedes Element mit der unten gezeigten Methode zu drucken. 🎜rrreee🎜Mit Hilfe der for-Schleife kann die äquivalente gedruckte Folge aufsteigender Elemente sequentiell generiert werden, 🎜🎜wie unten gezeigt:🎜rrreee🎜Range-Beispiel in Java 🎜🎜Hier sind Beispiele Erwähnt:🎜🎜Beispiel Nr. 1🎜🎜Java-Programm zur Implementierung der IntStream Range-Funktion. 🎜🎜Code:🎜rrreee🎜Ausgabe:🎜🎜🎜🎜Importieren Sie zunächst das Paket java.util.stream.IntStream. Erstellen Sie dann einen IntStream st, dem Sie Elemente hinzufügen möchten. Während der Erstellung des Streams wird die Methode range(32, 45) verwendet, um Elemente hinzuzufügen, einschließlich 32 Elementen und ausschließend 45 Elemente. Wenn der Code ausgeführt wird, wird ein geordneter IntStream in einem inkrementellen Schritt von 32 bis 44 zurückgegeben, wie in der Beispielausgabe gezeigt. 🎜🎜Beispiel Nr. 2🎜🎜Java-Programm implementiert die LongStream-Bereichsfunktion. 🎜🎜Code:🎜rrreee🎜Ausgabe:🎜🎜🎜🎜Ähnlich wie das obige Programm importieren Sie das Paket java.util.stream.LongStream. Erstellen Sie dann einen LongStreamst mit der Methode range(100001L, 100010L), um ihm Elemente hinzuzufügen. Während der Code ausgeführt wird, erfolgt ein schrittweiser Schritt zurück von 100001L auf 100010L, wie in der Beispielausgabe gezeigt. 🎜🎜Beispiel #3🎜🎜Java-Programm zur kombinierten Implementierung von LongStream- und IntStream-Bereichsfunktionen. 🎜🎜Code:🎜rrreee🎜Ausgabe:🎜🎜🎜🎜Importieren Sie die Pakete java.util.stream.IntStream und java.util.stream.LongStream. Erstellen Sie dann einen IntStreamstr und einen LongStreamst, denen Sie Elemente hinzufügen möchten. Verwenden Sie während der Erstellung des Streams die Methode range(32, 45), um dem IntStream Elemente hinzuzufügen, einschließlich 32 und ausschließlich 45. Verwenden Sie in ähnlicher Weise die Methode range(100001L, 100010L), um Elemente im LongStream hinzuzufügen. Wenn der Code ausgeführt wird, kehrt der sequenzierte IntStream von 32 auf 44 zurück und der LongStream kehrt von 100001L auf 100010L mit einem inkrementellen Schritt von 1 zurück. 🎜

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Range-Funktion in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!