How do I create ranges of numbers as Streams?

In Java, you can use IntStream, LongStream, or DoubleStream to create ranges of numbers as streams. For example, to create a range of integer numbers, we can call the range() static method of the IntStream interface.

Here’s an example:

package org.kodejava.util;

import java.util.stream.IntStream;

public class IntRangeExample {
    public static void main(String[] args) {
        IntStream.range(1, 11).forEach(System.out::println);
    }
}

In this example, IntStream.range(1, 11) creates a stream of integers from 1 (inclusive) to 11 (exclusive), which means it will print numbers from 1 to 10.

Suppose you have an application, where you need to assign a unique-id to each book in the library inventory. You may generate a sequence of unique IDs using a stream.

package org.kodejava.util;

import java.util.stream.IntStream;

public class IntRangeOtherExample {
    public static void main(String[] args) {
        final int START_ID = 1001;
        final int NUM_BOOKS = 10;

        IntStream.range(START_ID, START_ID + NUM_BOOKS)
                .forEach(id -> System.out.println("Assigned id for a new book: " + id));
    }
}

In this example, we’re starting id sequence from 1001 (START_ID), and we have NUM_BOOKS set to 10. So, We’re generating 10 unique ids starting from 1001, each for a new incoming book.

Or another scenario where you want a list of 10 random integers within a range (for example, to simulate test data):

package org.kodejava.util;

import java.util.Random;

public class RandomRangeExample {
    public static void main(String[] args) {
        final int MIN_VAL = 10;
        final int MAX_VAL = 100;
        final int NUM_ELEMENTS = 10;

        new Random()
                .ints(NUM_ELEMENTS, MIN_VAL, MAX_VAL)
                .forEach(System.out::println);
    }
}

Here, we’re generating NUMBER_ELEMENTS number of integers between MIN_VALUE and MAX_VALUE.

An example output of the last code snippet is:

42
46
54
30
67
69
46
11
39
59

The DoubleStream interface has several factory methods you can use to create ranges of double values. Here’s an example:

package org.kodejava.util;

import java.util.stream.DoubleStream;

public class DoubleStreamExample {
    public static void main(String[] args) {
        DoubleStream.iterate(0, n -> n + 0.5)
                .limit(10)
                .forEach(System.out::println);
    }
}

In this example, DoubleStream.iterate(0, n -> n + 0.5) creates a stream of double starting with 0 and then applying the unary function n -> n + 0.5 to each subsequent element. As a result, it will print out 0 followed by 0.5, 1.0, 1.5, etc., up to 4.5 as there are 10 elements due to .limit(10). Modify 0, 0.5 and 10 to match the start value, increment and the limit respectively that suit your needs.

For a real-world scenario, suppose we need double values to represent temperatures difference every half degree for the next 8 hours starting from 20 degrees Celsius. This can be represented as follows:

package org.kodejava.util;

import java.util.stream.DoubleStream;

public class DoubleStreamTemperature {
    public static void main(String[] args) {
        DoubleStream.iterate(20, c -> c + 0.5)
                .limit(16)
                .forEach(temp -> System.out.println("Predicted temperature for next hour: " + temp + "C"));
    }
}

In this example, DoubleStream.iterate(20, c -> c + 0.5) creates a stream starting with 20 (degrees Celsius in this context), and then by adding 0.5 to each subsequent temperature (which stands for temperature difference after an hour). .limit(16) keeps the listening for 8 hours only as we want temperature for every half an hour.

How do I use Stream.iterate() method?

The Stream.iterate() method in Java is used to generate a Stream of elements based on some iterative logic.

The simplest form Stream.iterate(initialValue, lambdaFunction) takes in an initial value and a UnaryOperator function to compute the next element in the series.

Here’s an example of using `Stream.iterate()“ to create a Stream of incremental numbers:

package org.kodejava.util;

import java.util.stream.Stream;

public class StreamIterate {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.iterate(0, n -> n + 1);
        stream
                .limit(10)
                .forEach(System.out::println);
    }
}

In this example, Stream.iterate(0, n -> n + 1) creates an infinite Stream starting from 0, where each next element is calculated by adding 1 to the previous element (n -> n + 1). The stream is then limited to the first 10 elements, and each of those elements is printed to the console.

Since Java 9, Stream.iterate() also has an overloaded method Stream.iterate(initialValue, predicate, function) which also takes a Predicate to specify the condition when to stop iteration.

For example:

package org.kodejava.util;

import java.util.stream.Stream;

public class StreamIterateExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.iterate(0, n -> n <= 10, n -> n + 1);
        stream.forEach(System.out::println);
    }
}

In this example, Stream.iterate(0, n -> n <= 10 , n -> n + 1) creates a Stream starting from 0, and ends when the value exceeds 10. Each next element is calculated by adding 1 to the previous element (n -> n + 1). Each of those elements is then printed to the console.

How do I use Stream.generate() method?

The Stream.generate() method in Java is used to create an infinite stream of data, typically used when the programmer needs a limitless supply of data to be processed.

Here’s an example of how you might use Stream.generate():

package org.kodejava.util;

import java.util.stream.Stream;

public class StreamGenerate {
    public static void main(String[] args) {
        Stream<String> stringStream = Stream.generate(() -> "Hello, World!");

        stringStream
                .limit(5)
                .forEach(System.out::println);
    }
}

The output of this code snippet is:

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

In this example, Stream.generate() is used to create an infinite stream of the String "Hello, World!". The limit(5) method is used to limit the infinite stream to just the first five elements, and forEach(System.out::println) is used to print each of the first five elements to the console.

However, be careful while using Stream.generate() without limit() as it can lead to infinite loop. Generally, limit() is used with Stream.generate() to avoid this.

Here’s how you would use it with the Random class to generate an infinite stream of random numbers:

package org.kodejava.util;

import java.util.Random;
import java.util.stream.Stream;

public class StreamGenerateRandomNumber {
    public static void main(String[] args) {
        Stream<Integer> randomNumbers = Stream.generate(new Random()::nextInt);

        randomNumbers
                .limit(10)
                .forEach(System.out::println);
    }
}

This will output something like:

-2134800739
730041861
357210260
1964364949
-1083197494
-1988345642
-1851656161
-562751737
-1777126198
-1030758565

In this case, new Random()::nextInt is a supplier function that provides an infinite stream of random integers. The limit(10) method is used to limit the stream to the first 10 random integers.

What is Java Stream API?

The Java Stream API is a powerful tool introduced in Java 8. It is designed to process data in a declarative way. More specifically, it makes it easy to process sequences of data elements, such as collections or arrays.

Here are some key points about Java Stream API:

  1. Non-mutating: Operations on streams do not mutate the source of the stream, rather they produce a new stream that encapsulates the result.
  2. Functional in nature: An important concept in Stream API is that it allows computations on data to be expressed as lambda functions.
  3. Lazy computation: The computation on the source data is only performed when it’s actually needed. This can result in significant performance boosts.
  4. Parallelizable operations: Stream operations can transparently take advantage of multicore architectures, leading to significantly increased performance.

Here’s a simple example of how the Stream API might be used:

import java.util.List;
import java.util.stream.Stream;

public class Stream1 {
    public static void main(String[] args) {
        List<String> collected = Stream.of("Java", "Kotlin", "Scala")
                .filter(lang -> lang.startsWith("J"))
                .map(String::toUpperCase)
                .toList();
    }
}

In this example, we create a stream from a list of strings, filter to keep only those that start with “J”, convert them to uppercase, and then collect them into a new list.

In Java, there are several ways to create Streams. Here are some common methods:

  • From Collection or Arrays: All collections in Java which extends Collection interface can be converted to Stream.
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Stream2 {
    public static void main(String[] args) {
        List<String> myList = new ArrayList<>();
        Stream<String> myStream = myList.stream();

        String[] myArray = new String[]{"a", "b", "c"};
        Stream<String> myArrayStream = Arrays.stream(myArray);
    }
}
  • Using Stream.of(): You can create a Stream from specific set of object references with Stream.of().
import java.util.stream.Stream;

public class Stream3 {
    public static void main(String[] args) {
        Stream<String> streamOfString = Stream.of("a", "b", "c");
    }
}
  • From File: In the java.nio.file package, you can use Files.lines(), to read a file into a Stream of lines.
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class Stream4 {
    public static void main(String[] args) {
        try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • Stream.iterate() and Stream.generate(): These methods let you generate streams in a programmatic way.
import java.util.stream.Stream;

public class Stream5 {
    public static void main(String[] args) {
        Stream<String> stringStream = Stream.generate(() -> "element").limit(10);
        Stream<Integer> integerStream = Stream.iterate(0, n -> n + 1).limit(10);
    }
}

In the above example, Stream.generate() creates a Stream of specified lambda function (always “element” in this case) which can be limited using limit(). Stream.iterate() creates a Stream based on the initial element and a lambda function for subsequent elements.

  • Using Stream.builder(): You can create streams using Stream.builder() where you can add elements in a Stream in a programmatic way.
import java.util.stream.Stream;

public class Stream6 {
    public static void main(String[] args) {
        Stream.Builder<String> myStreamBuilder = Stream.<String>builder().add("a").add("b").add("c");
        Stream<String> stringStream = myStreamBuilder.build();
    }
}

Remember, once a Stream is consumed, it can’t be reused. You have to create a new stream to perform any new computation.

How do I sort strings based on their length?

You can sort strings based on their length using the sort method combined with a custom comparator. In the code snippet below we are going to use the Arrays.sort() method. We pass an array of string to the sort() method and also a lambda expression as the custom comparator.

Here is how you’d do it in Java:

package org.kodejava.util;

import java.util.Arrays;

public class SortStringsExample {
    public static void main(String[] args) {
        String[] strings = {"Hello", "World", "Java", "is", "beautiful"};

        // Sort the array based on string length
        Arrays.sort(strings, (a, b) -> a.length() - b.length());

        // Print the sorted array
        Arrays.stream(strings).forEach(System.out::println);
    }
}

In this example, an array of strings is sorted in increasing order of their lengths. If you want to sort them in descending order, you can change the comparator to (a, b) -> b.length() - a.length().

The output of the code snippet above is:

is
Java
Hello
World
beautiful