How do I use Collectors.toSet() method?

By I Wayan Saryada in Java 8, Stream API 0 Comment

The Collectors.toSet() method is a method from the java.util.stream.Collectors class that provides a Collector able to transform the elements of a stream into a Set.

Here’s an example of using the Collectors.toSet() method:

package org.kodejava.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class CollectorsToSet {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("Apple", "Banana", "Orange", "Apple", "Banana", "Cherry");

        Set<String> uniqueFruits = fruits.stream()
                .collect(Collectors.toSet());

        System.out.println(uniqueFruits);
    }
}

Output:

[Apple, Cherry, Orange, Banana]

In this example, we have a List<String> of fruits, which contains some duplicate elements. When we stream the list and collect it into a Set using Collectors.toSet(), the result is a Set<String> that only includes the unique fruit names, as a Set doesn’t allow duplicate values.

Remember, like collect other terminal operation, it triggers the processing of the data and will return a collection or other specificity defined type. In case of Collectors.toSet(), the result is a Set.

How do I use Collectors.toList() method?

By I Wayan Saryada in Java 8, Stream API 0 Comment

The Collectors.toList() method is a convenient method in the java.util.stream.Collectors class that provides a Collector to accumulate input elements into a new List.

Here is a simple example of how to use Collectors.toList():

package org.kodejava.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CollectorsToList {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());

        System.out.println(evenNumbers);
    }
}

Output:

[2, 4, 6, 8]

In this example, we create a stream of numbers and filter it to only include the even numbers. Then we collect the output into a List using Collectors.toList(). The result is a List<Integer> that only includes the even numbers.

Remember that collect is a terminal operation (meaning it triggers the processing of the data) and it returns a collection or other desired result type. In case of Collectors.toList(), the result is a List.

What are collectors in Java Stream API?

By I Wayan Saryada in Java 8, Stream API 0 Comment

In Java, the Collector is a concept in the Stream API which provides a way to collect the results of various operations in the stream.

It is used in conjunction with the collect method of the Stream interface. The collect method allows you to accumulate the elements of the stream into a summary result.

Here’s an example of how you can use a Collector:

package org.kodejava.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CollectToList {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("A", "AA", "AAA", "B", "BB", "BBB");
        List<String> collectedList = stringList.stream()
                .filter(s -> s.startsWith("A"))
                .collect(Collectors.toList());
    }
}

In the above example, the Collector used is Collectors.toList(), which will accumulate the stream’s elements into a List.

java.util.stream.Collectors is a utility class that contains various methods for creating common kinds of Collectors.

A Collector can perform transformations on the input elements, accumulation of processed input elements into a container, and combining of two result containers. In fact, Collector is extremely flexible, and you can supply Collector with your own functions for these purposes if you need to.

Collector is an interface in the java.util.stream package. It’s used along with the collect() terminal operation to consume elements from a stream and store them into a collection or possibly other types of result container.

public interface Collector<T, A, R> {
    Supplier<A> supplier();
    BiConsumer<A, T> accumulator();
    BinaryOperator<A> combiner();
    Function<A, R> finisher();
    Set<Characteristics> characteristics();
}

Each Collector contains four functions: supplier(), accumulator(), combiner(), and finisher(), and a characteristics set which provides hints for the implementation to optimize processing.

  1. Supplier: It creates a new mutable result container, where T is the type of items in the stream to be collected, and A is the type of the mutable accumulation container.
  2. Accumulator: It incorporates an additional input element into a result container.
  3. Combiner: It combines two result containers into one. This is used in parallel processing.
  4. Finisher: It performs the final transformation from the intermediate accumulation type A to the final result type R.
  5. Characteristics: It returns a Set of Collector.Characteristics indicating the characteristics of this Collector. This can be CONCURRENT, UNORDERED or IDENTITY_FINISH.

Here’s an example demonstrating how to create a custom collector:

package org.kodejava.stream;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collector;

public class CustomCollector {
    public static void main(String[] args) {
        Collector<String, ?, LinkedList<String>> toLinkedList =
                Collector.of(
                        LinkedList::new,              // The Supplier
                        LinkedList::add,              // The Accumulator
                        (left, right) -> {            // The Combiner
                            left.addAll(right);
                            return left;
                        },
                        Collector.Characteristics.IDENTITY_FINISH
                );

        List<String> strings = Arrays.asList("a", "b", "c", "d");
        LinkedList<String> collectedStrings = strings.stream()
                .collect(toLinkedList);
    }
}

In the built-in java.util.stream.Collectors class, there are various static methods which return Collector instances for common use cases, such as toList(), toSet(), joining(), groupingBy(), partitioningBy(), and others.

How do I use sorted method in Java Stream API?

By I Wayan Saryada in Java 8, Stream API 0 Comment

In the Java Stream API, the sorted() method is used to sort elements in a stream. The sorted() method returns a stream consisting of the elements of the original stream, sorted according to natural order. If the elements of the stream are not Comparable, a java.lang.ClassCastException may be thrown when the terminal operation is executed.

Take a look at this example:

package org.kodejava.stream;

import java.util.stream.Stream;

public class SortedString {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("d", "a", "b", "c", "e");
        stream.sorted().forEach(System.out::println);
    }
}

In this code, we create a stream of String objects and sort it using the sorted() operation. The forEach method is a terminal operation that processes the sorted stream.

If you would like to sort objects of a custom class, you may need to supply your own comparator:

package org.kodejava.stream;

import java.util.Comparator;
import java.util.stream.Stream;

public class SortedCustomComparator {

    public static void main(String[] args) {
        Stream<User> usersStream = Stream.of(
                new User("John", 30),
                new User("Rosa", 25),
                new User("Adam", 23));

        usersStream
                .sorted(Comparator.comparing(User::getAge))
                .forEach(System.out::println);
    }

    static class User {
        String name;
        int age;

        User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        String getName() {
            return name;
        }

        int getAge() {
            return age;
        }

        @Override
        public String toString() {
            return "User{" + "name='" + name + '\'' + ", age=" + age + '}';
        }
    }
}

In this case, the sorted() method takes a Comparator argument, which is created using a lambda function. This comparator compares User objects by their ages.

In Java Stream API, you can use the sorted() and limit() methods together, but their ordering impacts performance. The sorted() method sorts all the elements in the stream, whereas limit(n) shortens the stream to be no longer than n elements in length.

If you call limit() before sorted(), like:

stream.limit(10).sorted()

The operation will only sort the first 10 elements from the stream.

But if you call sorted() before limit(), like:

stream.sorted().limit(10)

The operation will sort the entire stream, which may be much larger and more time-consuming, and then cut down the result to only keep the first 10 items.

So, if your task is to ‘find the smallest (or largest) n elements’, it is more efficient to first sort the stream and then limit it. If you want to ‘sort the first n elements’, you should limit the stream first and then sort it.

How do I use limit method in Java Stream API?

By I Wayan Saryada in Java 8, Stream API 0 Comment

The limit(long maxSize) method in Java’s Stream API is used for reducing the size of the stream. It takes a single parameter, maxSize, which is a long value that represents the maximum number of elements that the stream should be limited to.

The primary purpose and usefulness of the limit() method can be summarized as follows:

  1. Short-circuit Operation: It provides a way to work with infinite streams. Even if your stream is infinite, using limit() allows you to get a finite number of elements.

  2. Performance Enhancement: Since limit() short-circuits the stream, it can significantly improve performance by reducing the number of operations performed, especially in large streams.

  3. Control Stream Size: The limit() method allows you to reduce the number of elements in the stream according to your needs without changing the original data source.

Here is a simple example of how to use it:

package org.kodejava.stream;

import java.util.stream.*;

public class StreamLimit {
    public static void main(String[] args) {
        Stream<Integer> numbersStream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        numbersStream
                .limit(4)
                .forEach(System.out::println);
    }
}

Output:

1
2
3
4

In this code, we have a stream of nine numbers, but we are limiting this stream to just the first four elements, so only the numbers 1 to 4 are displayed on the console.

Please note that if the size of this stream is smaller than the maxSize then the same amount of stream will be returned. If the size of the stream is greater than the maxSize then the size of the stream will be maxSize.