Complete Guide: Java Intstream

By Harish Gowda | | 6 minutes

In this guide we will learn how to use IntStream in Java.

You might have encountered IntStream while working in your project.

Time to go into some in-depth details!

Basically, IntStream is a special form of stream for working with primitive int values.

Before performing any operation on IntStream, let us first understand how they are created.

Creating IntStream

Using IntStream.of() method

Below is the simple way of creating streams.

It creates stream from a fixed set of values you want.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        IntStream intStream = IntStream.of(10, 20, 30, 40);
        intStream.forEach(System.out::println); //10,20,30,40 

    }
}

Using IntStream.range() method

Using IntStream.range() creates a sequential stream based on given range from start(inclusive) to end(exclusive).

In the below example we need sequential int stream starting from 1 to 4.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        IntStream intStream = IntStream.range(1,5);
        intStream.forEach(System.out::println);//1,2,3,4

    }
}

Using IntStream.rangeClosed() method

It is similar to IntStream.range() but start and end are inclusive.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        IntStream intStream = IntStream.rangeClosed(1,5);
        intStream.forEach(System.out::println);//1,2,3,4,5

    }
}

Using IntStream.iterate() method

IntStream.iterate() creates an infinite stream starting from an initial value and subsequent values are based on the logic provided to IntUnaryOperator.

In below example it creates stream starting from 3 and each subsequent element is multiplied by 2.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        IntStream.iterate(3, n->n*2)
                .limit(3)
                .forEach(System.out::println);// 3,6,12

    }
}

Using IntStream.generate() method

IntStream.generate() creates an infinite stream starting from an initial value and subsequent values are based on the logic provided by Supplier.

Here, Supplier generates random integer.

Since it is an infinite stream, we limit this by using limit() method and print each element as shown in below example.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package examples;

import java.util.stream.IntStream;
public class App {
public static void main(String[] args) {

        IntStream.generate(() -> (int)(Math.random()*100))
                .limit(3)
                .forEach(System.out::println);// 73,22,26

    }
}

Operations on IntStream

Now we will learn how to perform operations on IntStream.

Filter operation

We can filter IntStream elements as shown in below example.

Here we are filtering elements which are greater than 8.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        IntStream.range(1,10)
                .filter(n-> n> 8)
                .forEach(System.out::println); //9

    }
}

Map operation

map() method applies function on each element of the stream and returns a new stream.

In below example we are returning double of each element by using map() method on IntStream.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        IntStream.range(1,5)
                .map(n-> n*2)
                .forEach(System.out::println); // 2,4,6,8

    }
}

Reduce operation

We can perform a single operation on all the elements which are present in the stream.

In the below example we sum all the integers which are present in the stream using reduce operation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        int num = IntStream.range(1, 5)
                .reduce(0, Integer::sum); //10
        System.out.println(num);


    }
}

Getting maximum element in the IntStream

We can get maximum element in the IntStream using max() method.

Below example shows how to get maximum element in an IntStream.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        int max = IntStream.range(1, 5)
                .max().orElse(-1);
        System.out.println(max); //4


    }
}

Getting minimum element in the IntStream

We can get minimum element in the IntStream using min() method.

Below example shows how to get minimum element in an IntStream.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        int min = IntStream.range(1, 5)
                .min().orElse(-1);
        System.out.println(min); //1


    }
}

Getting average of all elements in the IntStream

We can get average of all elements in the IntStream using average() method.

Below example shows how to get average of all elements in an IntStream.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        double avg = IntStream.range(1, 5)
                .average().orElse(0.0);
        System.out.println(avg); //2.5


    }
}

Getting sum of all elements in the IntStream

We can get sum of all elements in the IntStream using sum() method.

Below example shows how to get sum of all elements in an IntStream.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        double sum = IntStream.range(1, 5)
                .sum();
        System.out.println(sum); //10.0


    }
}

Getting count of all elements in the IntStream

We can get count of all elements in the IntStream using count() method.

Below example shows how to get count of all elements in an IntStream.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package examples;

import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        long count = IntStream.range(1, 5)
                .count();
        System.out.println(count); //4


    }
}

Converting IntStream to another data type

Convert IntStream to List

Since IntStream is stream of primitive ints we must first box the elements so that they are converted to Integer objects.

Then we can collect them in a List as shown in below example.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package examples;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        List<Integer> nums = IntStream.range(1, 5)
                .boxed()
                .collect(Collectors.toList());

        System.out.println(nums); //[1, 2, 3, 4]


    }
}

Convert IntStream to String

Below example showcases how to convert IntStream to String.

First you map integer to string using mapToObj and then you join them using `Collectors.joining'.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package examples;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) {

        String result = IntStream.range(1, 5)
                .mapToObj(String::valueOf)
                .collect(Collectors.joining(","));
        System.out.println(result);//1,2,3,4
    }
}

Convert IntStream to Stream

IntStream is a sequence of primitive integers.

To convert to Stream of Integer objects,we need to use ‘boxed()’ method which will return stream of Integer objects as shown in below example.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package examples;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class App {

    public static void main(String[] args) {

        Stream<Integer> stream = IntStream.range(1, 3).boxed();
        stream.forEach(System.out::println);
    }
}

Conclusion

I hope you learnt how to create,manipulate and convert stream of integers using IntStream!!!!