Java IntStream range() Method

The range() method in Java, part of the java.util.stream.IntStream interface, is used to create a sequential ordered IntStream from a start value (inclusive) to an end value (exclusive). This method is useful for generating a stream of consecutive integer values.

Table of Contents

1. Introduction
2. range() Method Syntax
3. Understanding range()
4. Examples
   • Basic Usage
   • Using range() with Other Stream Operations
5. Real-World Use Case
6. Conclusion

Introduction

The range() method returns a stream consisting of the elements in the specified range. This method is particularly useful when you need to generate a stream of consecutive integers.

range() Method Syntax

The syntax for the range() method is as follows:

static IntStream range(int startInclusive, int endExclusive)

Parameters:

• startInclusive: The inclusive initial value.
• endExclusive: The exclusive upper bound.

Returns:

• A sequential IntStream for the range of int elements.

Throws:

• This method does not throw any exceptions.

Understanding range()

The range() method generates a stream of integers starting from startInclusive and ending at endExclusive - 1. The generated stream is ordered and sequential.

Examples

Basic Usage

To demonstrate the basic usage of range(), we will create an IntStream using a range and print its elements.

Example

import java.util.stream.IntStream;

public class RangeExample {
    public static void main(String[] args) {
        // Create a stream from 1 to 4 (inclusive of 1, exclusive of 5)
        IntStream intStream = IntStream.range(1, 5);

        // Print the elements of the stream
        intStream.forEach(System.out::println);
    }
}

Output:

1
2
3
4

Using range() with Other Stream Operations

This example shows how to use range() in combination with other stream operations, such as mapping and filtering.

Example

import java.util.stream.IntStream;

public class RangeWithOtherOperationsExample {
    public static void main(String[] args) {
        // Create a stream from 1 to 9 (inclusive of 1, exclusive of 10)
        IntStream intStream = IntStream.range(1, 10);

        // Filter even numbers, map them to their squares, and print
        intStream.filter(n -> n % 2 == 0)
                 .map(n -> n * n)
                 .forEach(System.out::println);
    }
}

Output:

4
16
36
64

Real-World Use Case

Generating Indices for Iteration

In real-world applications, the range() method can be used to generate indices for iteration over arrays, lists, or other data structures.

Example

import java.util.stream.IntStream;

public class GenerateIndicesExample {
    public static void main(String[] args) {
        String[] names = {"Alice", "Bob", "Charlie", "David"};

        // Use range() to generate indices and print each name with its index
        IntStream.range(0, names.length)
                 .forEach(i -> System.out.println("Index: " + i + ", Name: " + names[i]));
    }
}

Output:

Index: 0, Name: Alice
Index: 1, Name: Bob
Index: 2, Name: Charlie
Index: 3, Name: David

Conclusion

The IntStream.range() method is used to create a sequential ordered IntStream from a start value (inclusive) to an end value (exclusive). This method is particularly useful for generating streams of consecutive integers. By understanding and using this method, you can efficiently generate and work with ranges of integer values in your Java applications.