Primitive streams: IntStream, LongStream and DoubleStream

For this lesson, we'll focus on the primitive side of streams: why these three types exist, how mapToInt and friends move between object and primitive pipelines, how numeric terminal operations differ from reduce and collectors, how ranges work, how strings expose characters as IntStream, and where overflow or Unicode can surprise you. Interviewers ask this because the code is tiny, but the answer reveals whether you can see the cost model behind a stream pipeline.

01Picture it first: a checkout belt with and without boxes

Picture a checkout belt carrying 10 million item prices. A primitive stream is the belt where every price is a bare 4-byte int. A Stream<Integer> is the belt where each price is first put into a small cardboard box, then the calculator opens each box before adding it.

The point is not that every boxed stream is bad. The point is that a numeric pipeline should not allocate wrappers when the API already gives you a raw-number path.

Fig. 1

A boxed Stream Integer pipeline allocates wrapper objects before summing, while an IntStream keeps raw int values through mapToInt and sum

Notice the three lanes. mapToInt crosses from object land to primitive land. Numeric terminals such as sum and summaryStatistics live on the primitive side. boxed and mapToObj cross back when a later API needs objects.

02Primitive streams under the hood: boxing, ranges and conversions

import java.util.List;

record Order(String id, int cents) { }

public class PrimitiveSumDemo {
    public static void main(String[] args) {
        List<Order> orders = List.of(
                new Order("o-1", 1_200),
                new Order("o-2", 800),
                new Order("o-3", 500)
        );

        int primitiveTotal = orders.stream()
                .mapToInt(Order::cents)
                .sum();

        int boxedTotal = orders.stream()
                .map(Order::cents)
                .reduce(0, Integer::sum);

        System.out.println(primitiveTotal); // 2500
        System.out.println(boxedTotal);     // 2500
    }
}

Both versions print the same result. The first one communicates the numeric intent better and gives the runtime a primitive pipeline. The second one creates a Stream<Integer> shape, which means values are references unless optimization removes the boxes.

Notice three things:

• Stream<T> is generic, and Java generics do not accept primitive type arguments. There is no Stream<int>.
• mapToInt takes a ToIntFunction<T>, so the extractor returns a primitive int through applyAsInt.
• IntStream.sum() is a terminal operation. Once you call it, the pipeline is consumed, just like any other stream terminal.

The three primitive stream types

Java gives exactly three primitive stream families:

There is no CharStream, ByteStream, ShortStream or FloatStream. The usual choice for char, byte and short is IntStream, because Java numeric promotion already treats them as int in many expressions. For float, use DoubleStream when the stream API is a good fit, or keep a loop if preserving float precision and memory layout is the point.

Ranges: range excludes the end, rangeClosed includes it

IntStream.range(start, endExclusive) behaves like a classic for (int i = start; i < end; i++). rangeClosed(start, endInclusive) includes the right side.

import java.util.stream.IntStream;

public class RangeDemo {
    public static void main(String[] args) {
        System.out.println(IntStream.range(1, 4).boxed().toList());       // [1, 2, 3]
        System.out.println(IntStream.rangeClosed(1, 4).boxed().toList()); // [1, 2, 3, 4]

        long count = LongStreamLike.countDays(1, 31);
        System.out.println(count); // 31
    }
}

class LongStreamLike {
    static long countDays(long firstDay, long lastDay) {
        return java.util.stream.LongStream.rangeClosed(firstDay, lastDay).count();
    }
}

I use range for zero-based indexes and half-open intervals because it matches arrays and List indexes. I use rangeClosed for domain ranges where both endpoints are spoken out loud: days 1 through 31, years 2020 through 2026, invoice numbers 1000 through 1010.

Many candidates lose a boundary element here. Say the endpoint rule in the variable name if the code is easy to misread: endExclusive, lastDayInclusive, fromInclusive.

Moving between object and primitive streams

Primitive streams are not subclasses of Stream<Integer>. They are separate interfaces with conversion methods at the edges.

import java.util.List;

record Product(String sku, int grams) { }

public class ConversionDemo {
    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("p-1", 200),
                new Product("p-2", 750),
                new Product("p-3", 1_200)
        );

        List<String> heavySkus = products.stream()
                .mapToInt(Product::grams)       // Product -> int
                .filter(grams -> grams >= 500)  // still IntStream
                .asLongStream()                 // int -> long widening
                .mapToObj(grams -> grams + "g")
                .toList();

        List<Integer> boxedWeights = products.stream()
                .mapToInt(Product::grams)
                .boxed()
                .toList();

        System.out.println(heavySkus);     // [750g, 1200g]
        System.out.println(boxedWeights);  // [200, 750, 1200]
    }
}