MACRO NEPAL
Generating Infinite Streams in Java
awiskar acharya
November 4, 2025
2:18 am

Introduction to Infinite Streams

Infinite streams are potentially unbounded sequences of elements that are generated on-demand. Java 8's Stream API provides powerful mechanisms for creating and working with infinite streams, enabling lazy evaluation and efficient processing of large or unlimited datasets.

Core Methods for Infinite Stream Generation

1. Stream.iterate()

2. Stream.generate()

3. Random Number Streams

4. Custom Infinite Streams

Basic Infinite Stream Creation

Using Stream.iterate()

import java.util.stream.Stream;
public class BasicInfiniteStreams {
public static void main(String[] args) {
// Simple infinite stream starting from 0, incrementing by 1
Stream<Integer> infiniteNumbers = Stream.iterate(0, n -> n + 1);
// Limited output to avoid infinite loop
infiniteNumbers.limit(10).forEach(System.out::println);
System.out.println("---");
// Fibonacci sequence using iterate
Stream.iterate(new long[]{0, 1}, fib -> new long[]{fib[1], fib[0] + fib[1]})
.map(fib -> fib[0])
.limit(15)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n---");
// More complex iteration with condition
Stream.iterate(1, n -> n < 1000, n -> n * 2)
.forEach(n -> System.out.print(n + " "));
}
}

Using Stream.generate()

import java.util.stream.*;
import java.util.function.Supplier;
import java.util.Random;
public class GenerateExamples {
public static void main(String[] args) {
// Infinite stream of random numbers
Stream<Double> randomNumbers = Stream.generate(Math::random);
randomNumbers.limit(5).forEach(System.out::println);
System.out.println("---");
// Infinite stream with custom supplier
Supplier<String> wordSupplier = new Supplier<String>() {
private int count = 0;
private final String[] words = {"Hello", "World", "Java", "Stream"};
@Override
public String get() {
return words[count++ % words.length];
}
};
Stream.generate(wordSupplier)
.limit(8)
.forEach(word -> System.out.print(word + " "));
System.out.println("\n---");
// Stateful supplier (generally not recommended)
class StatefulSupplier implements Supplier<Integer> {
private int current = 0;
@Override
public Integer get() {
return current++;
}
}
Stream.generate(new StatefulSupplier())
.limit(5)
.forEach(System.out::println);
}
}

Advanced Infinite Stream Patterns

Mathematical Sequences

import java.util.stream.*;
import java.math.BigInteger;
public class MathematicalSequences {
public static void main(String[] args) {
// Prime numbers sequence
System.out.println("First 10 prime numbers:");
primeNumbers().limit(10).forEach(n -> System.out.print(n + " "));
System.out.println("\n---");
// Factorial sequence
System.out.println("Factorials:");
factorialSequence().limit(6).forEach(n -> System.out.print(n + " "));
System.out.println("\n---");
// Powers of 2
System.out.println("Powers of 2:");
Stream.iterate(BigInteger.ONE, n -> n.multiply(BigInteger.TWO))
.limit(10)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n---");
// Triangular numbers
System.out.println("Triangular numbers:");
triangularNumbers().limit(10).forEach(n -> System.out.print(n + " "));
}
// Infinite stream of prime numbers
public static Stream<Integer> primeNumbers() {
return Stream.iterate(2, n -> n + 1)
.filter(MathematicalSequences::isPrime);
}
private static boolean isPrime(int number) {
if (number < 2) return false;
for (int i = 2; i <= Math.sqrt(number); i++) {
if (number % i == 0) return false;
}
return true;
}
// Infinite stream of factorials
public static Stream<Long> factorialSequence() {
return Stream.iterate(new long[]{1, 1}, 
pair -> new long[]{pair[0] + 1, pair[1] * (pair[0] + 1)})
.map(pair -> pair[1]);
}
// Infinite stream of triangular numbers
public static Stream<Integer> triangularNumbers() {
return Stream.iterate(new int[]{1, 1}, 
pair -> new int[]{pair[0] + 1, pair[1] + pair[0] + 1})
.map(pair -> pair[1]);
}
}

Random Data Generators

import java.util.stream.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
public class RandomDataStreams {
public static void main(String[] args) {
Random random = new Random();
// Infinite stream of random integers
System.out.println("Random integers:");
Stream.generate(random::nextInt)
.limit(5)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n---");
// Random numbers within range
System.out.println("Random numbers 1-100:");
Stream.generate(() -> random.nextInt(100) + 1)
.limit(5)
.forEach(n -> System.out.print(n + " "));
System.out.println("\n---");
// Random strings
System.out.println("Random strings:");
randomStrings(8).limit(5).forEach(System.out::println);
System.out.println("---");
// Random dates
System.out.println("Random dates:");
randomDates().limit(3).forEach(System.out::println);
}
public static Stream<String> randomStrings(int length) {
String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
Random random = new Random();
return Stream.generate(() -> {
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < length; i++) {
sb.append(characters.charAt(random.nextInt(characters.length())));
}
return sb.toString();
});
}
public static Stream<Date> randomDates() {
return Stream.generate(() -> {
long now = System.currentTimeMillis();
long randomTime = ThreadLocalRandom.current()
.nextLong(now - (365L * 24 * 60 * 60 * 1000), now);
return new Date(randomTime);
});
}
}

Practical Applications

Data Simulation and Testing

import java.util.stream.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
class User {
private String name;
private int age;
private LocalDateTime registrationDate;
private double balance;
public User(String name, int age, LocalDateTime registrationDate, double balance) {
this.name = name;
this.age = age;
this.registrationDate = registrationDate;
this.balance = balance;
}
// Getters and toString
public String getName() { return name; }
public int getAge() { return age; }
public LocalDateTime getRegistrationDate() { return registrationDate; }
public double getBalance() { return balance; }
@Override
public String toString() {
return String.format("User{name='%s', age=%d, registered=%s, balance=%.2f}",
name, age, 
registrationDate.format(DateTimeFormatter.ISO_LOCAL_DATE),
balance);
}
}
public class DataSimulation {
private static final String[] FIRST_NAMES = {"John", "Jane", "Bob", "Alice", "Charlie", 
"Diana", "Eve", "Frank", "Grace", "Henry"};
private static final String[] LAST_NAMES = {"Smith", "Johnson", "Williams", "Brown", 
"Jones", "Garcia", "Miller", "Davis"};
public static void main(String[] args) {
// Generate infinite stream of random users
Stream<User> userStream = generateUsers();
System.out.println("Sample users:");
userStream.limit(5).forEach(System.out::println);
System.out.println("\n---");
// Users with specific criteria
System.out.println("Users under 30 with balance > 5000:");
generateUsers()
.filter(user -> user.getAge() < 30 && user.getBalance() > 5000)
.limit(3)
.forEach(System.out::println);
System.out.println("\n---");
// Statistical analysis on infinite stream
System.out.println("Statistics for first 1000 users:");
DoubleSummaryStatistics stats = generateUsers()
.limit(1000)
.mapToDouble(User::getBalance)
.summaryStatistics();
System.out.printf("Count: %d, Avg: %.2f, Min: %.2f, Max: %.2f%n",
stats.getCount(), stats.getAverage(), 
stats.getMin(), stats.getMax());
}
public static Stream<User> generateUsers() {
Random random = new Random();
return Stream.generate(() -> {
String firstName = FIRST_NAMES[random.nextInt(FIRST_NAMES.length)];
String lastName = LAST_NAMES[random.nextInt(LAST_NAMES.length)];
String name = firstName + " " + lastName;
int age = 18 + random.nextInt(50); // 18-67 years old
double balance = random.nextDouble() * 10000; // 0-10000 balance
// Random registration date in last 5 years
LocalDateTime now = LocalDateTime.now();
LocalDateTime registrationDate = now.minusDays(random.nextInt(1825));
return new User(name, age, registrationDate, balance);
});
}
}

Real-time Data Feed Simulation

import java.util.stream.*;
import java.util.*;
import java.util.concurrent.atomic.AtomicLong;
class StockPrice {
private String symbol;
private double price;
private double change;
private long timestamp;
public StockPrice(String symbol, double price, double change, long timestamp) {
this.symbol = symbol;
this.price = price;
this.change = change;
this.timestamp = timestamp;
}
// Getters and toString
public String getSymbol() { return symbol; }
public double getPrice() { return price; }
public double getChange() { return change; }
public long getTimestamp() { return timestamp; }
@Override
public String toString() {
return String.format("%s: $%.2f (%+.2f) @ %d", 
symbol, price, change, timestamp);
}
}
public class RealTimeDataFeeds {
private static final String[] STOCK_SYMBOLS = {"AAPL", "GOOGL", "MSFT", "AMZN", "TSLA", 
"FB", "NFLX", "NVDA", "AMD", "INTC"};
public static void main(String[] args) throws InterruptedException {
// Simulate real-time stock price feed
Stream<StockPrice> stockFeed = stockPriceFeed();
System.out.println("Live stock prices (press Ctrl+C to stop):");
// Process stream with delay to simulate real-time
stockFeed.forEach(price -> {
System.out.println(price);
try {
Thread.sleep(1000); // 1 second delay
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
});
}
public static Stream<StockPrice> stockPriceFeed() {
Random random = new Random();
AtomicLong timestamp = new AtomicLong(System.currentTimeMillis());
Map<String, Double> basePrices = new HashMap<>();
// Initialize base prices
for (String symbol : STOCK_SYMBOLS) {
basePrices.put(symbol, 100 + random.nextDouble() * 900); // $100-$1000
}
return Stream.generate(() -> {
String symbol = STOCK_SYMBOLS[random.nextInt(STOCK_SYMBOLS.length)];
double basePrice = basePrices.get(symbol);
// Random price change (-5% to +5%)
double changePercent = (random.nextDouble() - 0.5) * 0.1;
double newPrice = basePrice * (1 + changePercent);
double change = newPrice - basePrice;
basePrices.put(symbol, newPrice); // Update base price
StockPrice stockPrice = new StockPrice(symbol, newPrice, change, 
timestamp.getAndAdd(1000));
return stockPrice;
});
}
// Filtered feed for specific stocks
public static Stream<StockPrice> filteredStockFeed(String... symbols) {
Set<String> symbolSet = Set.of(symbols);
return stockPriceFeed()
.filter(price -> symbolSet.contains(price.getSymbol()));
}
}

Advanced Patterns and Techniques

Zipping Infinite Streams

import java.util.stream.*;
import java.util.function.BiFunction;
public class StreamZipping {
public static void main(String[] args) {
// Zip two infinite streams
Stream<Integer> numbers = Stream.iterate(1, n -> n + 1);
Stream<String> letters = Stream.iterate('A', ch -> (char)(ch + 1))
.map(String::valueOf);
System.out.println("Zipped number-letter pairs:");
zip(numbers, letters, (n, l) -> n + l)
.limit(10)
.forEach(System.out::println);
System.out.println("---");
// Fibonacci using zip-like operation
System.out.println("Fibonacci with custom zipping:");
Stream.iterate(new long[]{0, 1}, fib -> new long[]{fib[1], fib[0] + fib[1]})
.map(fib -> fib[0])
.limit(15)
.forEach(n -> System.out.print(n + " "));
}
// Custom zip function for two streams
public static <A, B, C> Stream<C> zip(Stream<A> streamA, 
Stream<B> streamB, 
BiFunction<A, B, C> zipper) {
Iterator<A> iteratorA = streamA.iterator();
Iterator<B> iteratorB = streamB.iterator();
return Stream.generate(() -> {
if (iteratorA.hasNext() && iteratorB.hasNext()) {
return zipper.apply(iteratorA.next(), iteratorB.next());
}
return null;
}).takeWhile(Objects::nonNull);
}
}

Stateful Infinite Streams

import java.util.stream.*;
import java.util.concurrent.atomic.*;
import java.util.function.Supplier;
public class StatefulStreams {
public static void main(String[] args) {
// Session ID generator
System.out.println("Session IDs:");
sessionIdStream().limit(5).forEach(System.out::println);
System.out.println("---");
// Increasing delay stream
System.out.println("Increasing delays:");
increasingDelayStream().limit(5).forEach(delay -> 
System.out.println(delay + "ms"));
System.out.println("---");
// Batch counter
System.out.println("Batch processing simulation:");
batchStream().limit(3).forEach(batch -> 
System.out.println("Processing batch: " + batch));
}
// Session ID with timestamp and counter
public static Stream<String> sessionIdStream() {
AtomicLong counter = new AtomicLong(0);
return Stream.generate(() -> {
long timestamp = System.currentTimeMillis();
long count = counter.incrementAndGet();
return String.format("SESSION-%d-%d", timestamp, count);
});
}
// Stream with increasing delays
public static Stream<Long> increasingDelayStream() {
AtomicLong delay = new AtomicLong(100); // Start with 100ms
return Stream.generate(() -> {
long currentDelay = delay.getAndUpdate(d -> Math.min(d * 2, 5000));
try {
Thread.sleep(currentDelay);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
return currentDelay;
});
}
// Batch processing simulation
public static Stream<List<Integer>> batchStream() {
AtomicInteger counter = new AtomicInteger(1);
AtomicInteger batchSize = new AtomicInteger(10);
return Stream.generate(() -> {
int currentBatch = counter.getAndIncrement();
int size = batchSize.get();
// Simulate processing
System.out.printf("Generating batch %d with %d items%n", currentBatch, size);
List<Integer> batch = Stream.iterate(0, n -> n + 1)
.limit(size)
.map(n -> n + (currentBatch - 1) * size)
.collect(Collectors.toList());
// Increase batch size gradually
if (currentBatch % 3 == 0) {
batchSize.updateAndGet(bs -> Math.min(bs * 2, 100));
}
return batch;
});
}
}

Performance Considerations and Best Practices

Memory Management

import java.util.stream.*;
import java.util.*;
public class PerformanceConsiderations {
public static void main(String[] args) {
// Good: Process elements immediately without storing
System.out.println("Processing without storage:");
Stream.generate(() -> "element")
.limit(1000000)
.map(String::toUpperCase)
.forEach(e -> {}); // Process without storing
// Bad: Collecting infinite stream (will run out of memory)
try {
Stream.generate(Math::random)
.collect(Collectors.toList()); // This will never complete
} catch (OutOfMemoryError e) {
System.out.println("OutOfMemoryError as expected!");
}
}
// Efficient processing of large streams
public static void processLargeStream() {
long startTime = System.currentTimeMillis();
long count = Stream.generate(new Random()::nextInt)
.limit(10_000_000)
.filter(n -> n % 2 == 0)
.count();
long endTime = System.currentTimeMillis();
System.out.printf("Processed %d even numbers in %d ms%n", 
count, endTime - startTime);
}
}

Error Handling in Infinite Streams

import java.util.stream.*;
import java.util.function.Supplier;
public class ErrorHandling {
public static void main(String[] args) {
// Robust stream with error handling
System.out.println("Robust stream with error handling:");
robustStream()
.limit(10)
.forEach(System.out::println);
System.out.println("---");
// Stream with retry mechanism
System.out.println("Stream with retry mechanism:");
streamWithRetry(3) // 3 retries
.limit(5)
.forEach(System.out::println);
}
public static Stream<String> robustStream() {
return Stream.generate(new Supplier<String>() {
private int count = 0;
@Override
public String get() {
try {
// Simulate occasional failures
if (count % 5 == 0) {
throw new RuntimeException("Simulated failure at count " + count);
}
return "Element-" + count++;
} catch (Exception e) {
System.err.println("Error generating element: " + e.getMessage());
return "Error-Recovery-" + count++;
}
}
});
}
public static Stream<String> streamWithRetry(int maxRetries) {
return Stream.generate(new Supplier<String>() {
private int count = 0;
private int consecutiveFailures = 0;
@Override
public String get() {
for (int attempt = 0; attempt <= maxRetries; attempt++) {
try {
// Simulate unreliable source
if (Math.random() < 0.3) { // 30% failure rate
throw new RuntimeException("Temporary failure");
}
consecutiveFailures = 0;
return "Success-" + count++;
} catch (Exception e) {
consecutiveFailures++;
System.err.printf("Attempt %d failed: %s%n", attempt + 1, e.getMessage());
if (attempt == maxRetries) {
throw new RuntimeException("Max retries exceeded", e);
}
// Optional: add delay between retries
try {
Thread.sleep(100 * (attempt + 1));
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException(ie);
}
}
}
return null; // Should never reach here
}
});
}
}

Conclusion and Best Practices

When to Use Infinite Streams

  1. Data Simulation: Generating test data or mock responses
  2. Real-time Feeds: Processing continuous data streams
  3. Mathematical Sequences: Generating mathematical progressions
  4. Resource Monitoring: Continuous monitoring of system resources
  5. Game Development: Procedural content generation

Best Practices

  1. Always use limit() or other short-circuiting operations
  2. Avoid stateful operations in parallel streams
  3. Use primitive streams (IntStream, LongStream, DoubleStream) for better performance
  4. Consider memory usage when working with large streams
  5. Handle exceptions properly in stream generators
  6. Use appropriate terminal operations that don't collect all elements

Performance Tips

  • Use parallel() judiciously for CPU-intensive operations
  • Prefer method references over lambda expressions
  • Use primitive streams to avoid boxing overhead
  • Consider using iterator() for more control over stream consumption

Infinite streams are a powerful feature in Java that, when used appropriately, can lead to elegant and efficient solutions for handling continuous or large datasets.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper