How do I create ranges of numbers as Streams?

By Wayan in Java 8, Stream API, Util Package 0 Comment

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?

By Wayan in Java 8, Stream API, Util Package 0 Comment

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?

By Wayan in Java 8, Stream API, Util Package 0 Comment

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.

How do I split a string using Pattern.splitAsStream() method?

By Wayan in Java 8, Regex 0 Comment

Pattern.splitAsStream() in Java is a method that allows us to split a string into a stream of substrings given a regex pattern. This can be useful when we’re working with large strings, and we want to process the substrings in a functional style using Java Streams.

Here’s a basic example of how you can use the Pattern.splitAsStream() method:

package org.kodejava.regex;

import java.util.regex.Pattern;
import java.util.stream.Stream;

public class SplitAsStreamExample {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile(",");
        String testStr = "one,two,three,four,five";
        Stream<String> words = pattern.splitAsStream(testStr);
        words.forEach(System.out::println);
    }
}

In this example, the pattern is a comma (,), and it is used to split the testStr string in the splitAsStream() call. This creates a Stream of strings. Each element in the stream is a substring of testStr that falls between the commas. The Stream.forEach() method is then used to print out each of these substrings. You can replace the comma with any regex pattern based on your requirements.

The result will be:

one
two
three
four
five

Consider a situation where we have a CSV (Comma Separated Values) file. We need to read the file, process each line and extract the fields. For this purpose, let’s use the BufferedReader, Pattern.splitAsStream(), and Java 8’s Stream API:

package org.kodejava.regex;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;

public class CSVProcessor {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile(",");
        String pathToFile = "country.csv";

        try (BufferedReader reader = new BufferedReader(new FileReader(pathToFile))) {
            List<String[]> records = reader.lines()
                    .map(line -> pattern.splitAsStream(line).toArray(String[]::new))
                    .toList();

            // Print each record
            records.forEach(record -> System.out.println(Arrays.toString(record)));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In this code snippet, we are reading a file line by line using a BufferedReader. Then for each line, we are splitting it into a Stream of fields using Pattern.splitAsStream(). This produces a Stream of fields for each line of the file. We then collect the fields into a list of String arrays, with each array representing a line in the CSV (as split by commas).

Finally, we print out each record (which is a String array) to the console.

Remember that Pattern.splitAsStream() returns a stream of String and we can use it effectively in a functional programming style, and it integrates very well with the Java’s Stream API.

How do I use Files.walk() method to read directory contents?

By Wayan in IO, Java 8 0 Comment

The Files.walk() method in Java is a handy method when it comes to reading directory contents. Files.walk() method returns a Stream object that you can use to process each of the elements (files or directories) in the directory structure.

This method walks the file tree in a depth-first manner, starting from the given path that you provide as its parameter. It visits all files and directories in the file tree.

Here’s a simple example of how to use it. In this case, we are printing out the path to each file/directory.

package org.kodejava.io;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class FileWalkExample {
    public static void main(String[] args) {
        Path start = Paths.get("D:/Games");
        try (Stream<Path> stream = Files.walk(start)) {
            stream.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Files.walk() also supports a maximum depth argument, so you can limit how deep into the directory structure you want to go. For example, Files.walk(start, 2) would only go two levels deep.

Please note: You should always close the stream after you’re done with it to free up system resources. This is done automatically here with a try-with-resources statement.