IntStream, LongStream, DoubleStream in Java

Table of Contents

Introduction

Java's primitive specialized streams - IntStream, LongStream, and DoubleStream - provide efficient alternatives to generic Stream<T> for working with primitive data types. These streams eliminate boxing overhead and offer specialized operations for numerical computations, making them essential for high-performance applications.

IntStream

Creation Methods

public class IntStreamExamples {
public void demonstrateCreation() {
// Range operations
IntStream range1 = IntStream.range(1, 10);        // 1 to 9 (exclusive)
IntStream range2 = IntStream.rangeClosed(1, 10);  // 1 to 10 (inclusive)
// From arrays
int[] numbers = {1, 2, 3, 4, 5};
IntStream fromArray = IntStream.of(numbers);
IntStream fromValues = IntStream.of(1, 2, 3, 4, 5);
// From other sources
IntStream generated = IntStream.generate(() -> (int) (Math.random() * 100))
.limit(10);
IntStream iterated = IntStream.iterate(0, n -> n + 2).limit(5);
// Empty stream
IntStream empty = IntStream.empty();
}
}

Common Operations

public class IntStreamOperations {
public void demonstrateOperations() {
int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// Statistical operations
IntSummaryStatistics stats = IntStream.of(numbers)
.summaryStatistics();
System.out.println("Count: " + stats.getCount());
System.out.println("Sum: " + stats.getSum());
System.out.println("Min: " + stats.getMin());
System.out.println("Max: " + stats.getMax());
System.out.println("Average: " + stats.getAverage());
// Aggregation operations
int sum = IntStream.of(numbers).sum();
OptionalInt max = IntStream.of(numbers).max();
OptionalInt min = IntStream.of(numbers).min();
OptionalDouble average = IntStream.of(numbers).average();
// Searching operations
OptionalInt firstEven = IntStream.of(numbers)
.filter(n -> n % 2 == 0)
.findFirst();
boolean anyMatch = IntStream.of(numbers)
.anyMatch(n -> n > 5);
boolean allMatch = IntStream.of(numbers)
.allMatch(n -> n > 0);
}
}

Advanced IntStream Usage

public class AdvancedIntStream {
public void demonstrateAdvancedUsage() {
// Generate prime numbers
IntStream primes = IntStream.rangeClosed(2, 100)
.filter(this::isPrime);
// Pythagorean triples
IntStream.rangeClosed(1, 50)
.boxed()
.flatMap(a -> 
IntStream.rangeClosed(a, 50)
.filter(b -> Math.sqrt(a * a + b * b) % 1 == 0)
.mapToObj(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)})
)
.limit(10)
.forEach(triple -> System.out.println(
Arrays.toString(triple)));
// Factorial calculation
int factorial = IntStream.rangeClosed(1, 5)
.reduce(1, (a, b) -> a * b);
}
private boolean isPrime(int number) {
return IntStream.rangeClosed(2, (int) Math.sqrt(number))
.allMatch(n -> number % n != 0);
}
// Matrix operations with IntStream
public void matrixOperations() {
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Sum of all elements
int totalSum = Arrays.stream(matrix)
.flatMapToInt(IntStream::of)
.sum();
// Row sums
int[] rowSums = Arrays.stream(matrix)
.mapToInt(row -> IntStream.of(row).sum())
.toArray();
// Column sums
int[] colSums = IntStream.range(0, matrix[0].length)
.map(col -> Arrays.stream(matrix)
.mapToInt(row -> row[col])
.sum())
.toArray();
}
}

LongStream

Creation and Operations

public class LongStreamExamples {
public void demonstrateLongStream() {
// Creation methods
LongStream range = LongStream.range(1L, 1_000_000L);
LongStream generated = LongStream.generate(() -> 
ThreadLocalRandom.current().nextLong(1000L))
.limit(100);
// Working with large numbers
long largeSum = LongStream.rangeClosed(1L, 10_000_000L)
.parallel()  // Efficient for large ranges
.sum();
// Statistical operations with large datasets
LongSummaryStatistics stats = LongStream.range(0L, 1_000_000L)
.map(n -> n * n)  // Squares of numbers
.summaryStatistics();
System.out.println("Large number stats: " + stats);
// Time measurement example
long startTime = System.nanoTime();
long result = LongStream.range(1L, 100000L)
.filter(n -> n % 2 == 0)
.map(n -> n * 2)
.sum();
long duration = System.nanoTime() - startTime;
System.out.println("Computation took: " + duration + " ns");
}
// Fibonacci sequence with LongStream
public void fibonacciSequence() {
LongStream fibonacci = LongStream.iterate(
new long[]{0L, 1L},
pair -> new long[]{pair[1], pair[0] + pair[1]})
.mapToLong(pair -> pair[0])
.limit(20);
fibonacci.forEach(System.out::println);
}
// Prime number generation for large numbers
public void largePrimeNumbers() {
LongStream largePrimes = LongStream.rangeClosed(1_000_000L, 1_000_100L)
.filter(this::isPrime)
.parallel();
largePrimes.forEach(prime -> 
System.out.println("Large prime: " + prime));
}
private boolean isPrime(long number) {
if (number < 2) return false;
return LongStream.rangeClosed(2, (long) Math.sqrt(number))
.allMatch(n -> number % n != 0);
}
}

DoubleStream

Creation and Mathematical Operations

public class DoubleStreamExamples {
public void demonstrateDoubleStream() {
// Creation from various sources
DoubleStream fromValues = DoubleStream.of(1.5, 2.7, 3.9, 4.2);
DoubleStream generated = DoubleStream.generate(Math::random)
.limit(100);
DoubleStream iterated = DoubleStream.iterate(1.0, x -> x * 1.1)
.limit(10);
// Mathematical operations
double[] data = {1.2, 2.3, 3.4, 4.5, 5.6};
DoubleSummaryStatistics stats = DoubleStream.of(data)
.summaryStatistics();
System.out.println("Double Statistics: " + stats);
// Specialized mathematical operations
double sumOfSquares = DoubleStream.of(data)
.map(x -> x * x)
.sum();
double standardDeviation = Math.sqrt(
DoubleStream.of(data)
.map(x -> x - stats.getAverage())
.map(x -> x * x)
.sum() / stats.getCount()
);
}
// Scientific computations
public void scientificComputations() {
// Numerical integration - calculating π
double pi = DoubleStream.generate(Math::random)
.limit(1_000_000)
.parallel()
.mapToObj(x -> {
double xVal = x;
double yVal = Math.random();
return Math.sqrt(xVal * xVal + yVal * yVal) <= 1.0 ? 1 : 0;
})
.mapToDouble(val -> (double) val)
.average()
.orElse(0.0) * 4.0;
System.out.println("Approximated π: " + pi);
// Exponential function series expansion
double x = 2.0;
double exponential = DoubleStream.iterate(0, n -> n + 1)
.limit(20)
.map(n -> Math.pow(x, n) / factorial(n))
.sum();
System.out.println("e^" + x + " ≈ " + exponential);
}
private double factorial(double n) {
return DoubleStream.iterate(1.0, i -> i + 1.0)
.limit((long) n)
.reduce(1.0, (a, b) -> a * b);
}
// Statistical analysis
public void statisticalAnalysis() {
double[] dataset = {23.5, 45.2, 12.8, 78.9, 34.1, 56.7, 89.3, 67.8};
double mean = DoubleStream.of(dataset).average().orElse(0.0);
double variance = DoubleStream.of(dataset)
.map(x -> Math.pow(x - mean, 2))
.average()
.orElse(0.0);
double stdDev = Math.sqrt(variance);
System.out.printf("Mean: %.2f, Variance: %.2f, Std Dev: %.2f%n", 
mean, variance, stdDev);
// Normalization
double[] normalized = DoubleStream.of(dataset)
.map(x -> (x - mean) / stdDev)
.toArray();
System.out.println("Normalized data: " + Arrays.toString(normalized));
}
}

Conversion Between Stream Types

public class StreamConversionExamples {
public void demonstrateConversions() {
// IntStream conversions
IntStream intStream = IntStream.range(1, 6);
// To boxed Stream
Stream<Integer> boxedStream = intStream.boxed();
// To other primitive streams
LongStream longStream = intStream.asLongStream();
DoubleStream doubleStream = intStream.asDoubleStream();
// From boxed stream to primitive stream
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
IntStream fromBoxed = integerStream.mapToInt(Integer::intValue);
// Array conversions
int[] intArray = IntStream.range(1, 6).toArray();
Integer[] integerArray = IntStream.range(1, 6)
.boxed()
.toArray(Integer[]::new);
}
// Mapping between stream types
public void streamMapping() {
// IntStream to DoubleStream with transformation
DoubleStream squares = IntStream.range(1, 10)
.mapToDouble(n -> Math.pow(n, 2));
// DoubleStream to IntStream with rounding
IntStream rounded = DoubleStream.of(1.2, 2.7, 3.5, 4.9)
.mapToInt(d -> (int) Math.round(d));
// Complex transformation chain
LongStream result = IntStream.range(1, 100)
.filter(n -> n % 2 == 0)
.mapToLong(n -> (long) n * n)  // Convert to long to avoid overflow
.filter(n -> n > 1000);
}
}

Parallel Processing with Primitive Streams

public class ParallelPrimitiveStreams {
public void demonstrateParallelProcessing() {
// Parallel IntStream - ideal for CPU-intensive operations
long parallelSum = IntStream.range(1, 1_000_000)
.parallel()
.filter(n -> n % 2 == 0)
.map(n -> n * n)
.sum();
System.out.println("Parallel sum: " + parallelSum);
// Performance comparison
int size = 10_000_000;
long sequentialTime = measureTime(() -> 
IntStream.range(0, size)
.map(n -> intensiveCalculation(n))
.sum()
);
long parallelTime = measureTime(() -> 
IntStream.range(0, size)
.parallel()
.map(n -> intensiveCalculation(n))
.sum()
);
System.out.printf("Sequential: %dms, Parallel: %dms%n", 
sequentialTime, parallelTime);
}
private int intensiveCalculation(int n) {
// Simulate CPU-intensive work
return IntStream.range(0, 1000)
.reduce(n, (a, b) -> a ^ b);
}
private long measureTime(Runnable operation) {
long start = System.currentTimeMillis();
operation.run();
return System.currentTimeMillis() - start;
}
// Thread-safe operations with parallel streams
public void threadSafeOperations() {
// Using concurrent collections for parallel stream results
List<Integer> threadSafeList = Collections.synchronizedList(new ArrayList<>());
IntStream.range(0, 1000)
.parallel()
.filter(n -> n % 3 == 0)
.forEach(threadSafeList::add);
// Reduction operations are thread-safe
int product = IntStream.range(1, 10)
.parallel()
.reduce(1, (a, b) -> a * b);
System.out.println("Parallel product: " + product);
}
}

Real-World Use Cases

1. Data Analysis

public class DataAnalysisWithPrimitiveStreams {
public void analyzeSalesData() {
double[] sales = {12500.50, 23400.75, 18900.25, 26700.80, 31200.40};
DoubleSummaryStatistics salesStats = DoubleStream.of(sales)
.summaryStatistics();
System.out.println("Sales Analysis:");
System.out.printf("Total: $%,.2f%n", salesStats.getSum());
System.out.printf("Average: $%,.2f%n", salesStats.getAverage());
System.out.printf("Best Month: $%,.2f%n", salesStats.getMax());
System.out.printf("Worst Month: $%,.2f%n", salesStats.getMin());
// Identify months above average
long aboveAverage = DoubleStream.of(sales)
.filter(amount -> amount > salesStats.getAverage())
.count();
System.out.println("Months above average: " + aboveAverage);
}
// Sensor data processing
public void processSensorData() {
int[] sensorReadings = {23, 25, 22, 24, 26, 25, 23, 27, 24, 22};
// Remove outliers and calculate average
double average = IntStream.of(sensorReadings)
.sorted()
.skip(2)  // Remove lowest 2
.limit(sensorReadings.length - 4)  // Remove highest 2
.average()
.orElse(0.0);
System.out.println("Filtered sensor average: " + average);
}
}

2. Game Development

public class GameDevelopmentStreams {
// Character attribute generation
public void generateCharacterStats() {
Random random = new Random();
// Generate 6 ability scores (4d6 drop lowest)
int[] abilityScores = IntStream.generate(() -> 
random.ints(4, 1, 7)  // 4 dice rolls
.sorted()
.skip(1)          // drop lowest
.sum())           // sum remaining 3
.limit(6)                 // 6 ability scores
.toArray();
System.out.println("Ability scores: " + Arrays.toString(abilityScores));
// Calculate modifiers
int[] modifiers = IntStream.of(abilityScores)
.map(score -> (score - 10) / 2)
.toArray();
System.out.println("Ability modifiers: " + Arrays.toString(modifiers));
}
// Experience point calculations
public void experienceCalculations() {
int[] monsterXP = {50, 100, 200, 450, 700, 1100, 1800, 2300};
// Total XP for encounter
int totalXP = IntStream.of(monsterXP).sum();
// Adjusted XP for multiple monsters
double adjustedXP = totalXP * getMultiplier(monsterXP.length);
System.out.printf("Total XP: %d, Adjusted XP: %.1f%n", 
totalXP, adjustedXP);
}
private double getMultiplier(int monsterCount) {
return switch (monsterCount) {
case 1 -> 1.0;
case 2 -> 1.5;
case 3, 4, 5, 6 -> 2.0;
case 7, 8, 9, 10 -> 2.5;
case 11, 12, 13, 14 -> 3.0;
default -> 4.0;
};
}
}

Performance Considerations and Best Practices

public class StreamPerformanceBestPractices {
public void performanceTips() {
// 1. Use primitive streams to avoid boxing overhead
long sum = IntStream.range(1, 1000000).sum();  // Good
// vs
long sumBoxed = Stream.iterate(1, n -> n + 1)
.limit(1000000)
.mapToInt(Integer::intValue)
.sum();  // Boxing overhead
// 2. Use range/rangeClosed for sequential integers
IntStream.range(0, 1000)  // Efficient
.forEach(i -> {});
// 3. Prefer method references
DoubleStream.of(1.0, 2.0, 3.0)
.map(Math::sqrt)  // Good - method reference
.toArray();
// 4. Use parallel streams for large, CPU-intensive operations
long largeSum = LongStream.range(1, 10000000)
.parallel()
.filter(n -> n % 2 == 0)
.sum();
// 5. Avoid stateful operations in parallel streams
int[] badParallel = IntStream.range(1, 1000)
.parallel()
.sorted()  // Stateful - can hurt performance
.toArray();
}
// Memory efficiency with large datasets
public void memoryEfficientProcessing() {
// Process large datasets in chunks
int chunkSize = 10000;
long total = 0;
for (int i = 0; i < 1_000_000; i += chunkSize) {
int chunkSum = IntStream.range(i, Math.min(i + chunkSize, 1_000_000))
.sum();
total += chunkSum;
}
System.out.println("Total with chunking: " + total);
}
}

Conclusion

Primitive specialized streams (IntStream, LongStream, DoubleStream) offer significant performance benefits over their boxed counterparts by eliminating autoboxing overhead and providing specialized operations for numerical computations. They are particularly valuable for:

Mathematical computations and statistical analysis
Large dataset processing with parallel execution
Game development and simulation calculations
Scientific computing and data analysis
Performance-critical applications where every CPU cycle counts

By understanding the strengths and appropriate use cases for each primitive stream type, developers can write more efficient and expressive code for numerical processing in Java.