Java 8 Features — Streams and Optional

1. Java 8 Streams Overview

Streams

To process objects of a collection, the Stream concept was introduced in Java 8.

Stream s = c.stream();

The stream() method is a default method added to the Collection interface in Java 8.

Stream is an interface present in java.util.stream.

2. Difference Between Collection and Stream

3. Java 8 Stream Features

4. Stream Processing Phases

The source describes processing Stream objects in two phases:

Configuration

Configuration can be performed using either:

Processing

After configuration, the objects can be processed using several methods such as:

5. Filtering with filter()

The filter() method is used to filter elements from a collection based on a boolean condition.

public Stream filter(Predicate<T> t)

The Predicate can be a boolean-valued function or Lambda Expression.

Stream s = c.stream();

Stream s1 =
    s.filter(i -> i % 2 == 0);

6. Mapping with map()

If we want to create a separate/new object for every object present in the collection based on our requirement, we can use the map() method.

public Stream map(Function f);

The function can be represented by a Lambda Expression.

Stream s = c.stream();

Stream s1 =
    s.map(i -> i + 10);

7. flatMap()

The source describes flatMap() as a combination of transformation and flattening.

The notes distinguish the two operations by describing map as processing each value, whereas flatMap produces individual elements from the mapped result.

8. Stream Processing Operations

9. collect()

The collect() method collects elements from the stream and adds them to the result/collection specified by the argument.

List<String> names =
    Arrays.asList(
        "Alice",
        "Bob",
        "Charlie"
    );

List<String> result =
    names.stream()
         .collect(Collectors.toList());

10. String.join() and Collectors.joining()

String.join()

String result =
    String.join(
        "-",
        "2015",
        "10",
        "31"
    );

List<String> list =
    Arrays.asList(
        "java",
        "python",
        "nodejs",
        "ruby"
    );

String result2 =
    String.join(", ", list);

Collectors.joining()

List<String> list =
    Arrays.asList(
        "java",
        "python",
        "nodejs",
        "ruby"
    );

String result =
    list.stream()
        .map(x -> x)
        .collect(
            Collectors.joining(" | ")
        );

11. Optional Class

Optional is a container object used to contain non-null objects. It can represent a value as available or not available instead of repeatedly checking for null values.

Example

public class OptionalDemo {

    public static void main(String[] args) {

        String[] words =
            new String[10];

        Optional<String> checkNull =
            Optional.ofNullable(words[5]);

        if (checkNull.isPresent()) {

            String word =
                words[5].toLowerCase();

            System.out.print(word);

        } else {

            System.out.println(
                "word is null"
            );
        }
    }
}

12. Optional Methods

Creation Methods

Core / Utility Methods

13. Advantages of Java 8 Optional

Optional<String> gender =
    Optional.of("MALE");

String answer1 = "Yes";
String answer2 = null;

System.out.println(
    "Non-Empty Optional: " + gender
);

System.out.println(
    "Non-Empty Optional: Gender value = "
    + gender.get()
);

System.out.println(
    "Empty Optional: "
    + Optional.empty()
);

System.out.println(
    "ofNullable on Non-Empty Optional: "
    + Optional.ofNullable(answer1)
);

System.out.println(
    "ofNullable on Empty Optional: "
    + Optional.ofNullable(answer2)
);

14. StringJoiner

StringJoiner is a new class added in Java 8 under the java.util package. It is useful for joining Strings using a delimiter, prefix and suffix.

The source lists two constructors:

StringJoiner(CharSequence delimiter)

StringJoiner(
    CharSequence delimiter,
    CharSequence prefix,
    CharSequence suffix
)

Example of StringJoiner

private static String PREFIX = "{";
private static String SUFFIX = "}";

StringJoiner joiner =
    new StringJoiner(
        ", ",
        PREFIX,
        SUFFIX
    );

joiner
    .add("Core Java")
    .add("Spring Boot")
    .add("Angular");

System.out.println(
    joiner.toString()
);

15. join() Method in String Class

Java 8 introduced the join() method in the String class. It concatenates the given Strings using the specified delimiter and returns a new String.

public static String join(
    CharSequence delimiter,
    CharSequence... elements
)

Example

public class Example {

    public static void main(String args[]) {

        String str =
            String.join(
                "-",
                "You",
                "are",
                "learning",
                "join",
                "method",
                "in Java 8"
            );

        System.out.println(str);
    }
}

Output:

You-are-learning-join-method-in Java 8

Example of a List using join()

import java.util.List;
import java.util.Arrays;

public class Example {

    public static void main(String args[]) {

        // Converting an array of String to the list
        List<String> list =
            Arrays.asList(
                "Virat",
                "Ricky",
                "Peterson",
                "Watson"
            );

        String names =
            String.join(" | ", list);

        System.out.println(names);
    }
}

16. Java 8 HashMap / Map New Methods

17. Intermediate Operations

The source provides examples for several intermediate Stream operations.

filter()

public class FilterDemo {

    public static void main(String[] args) {

        List<String> names =
            List.of(
                "Alice",
                "Bob",
                "Amanda",
                "David"
            );

        List<String> names =
            names.stream()
                 .filter(
                     name ->
                         name.startsWith("A")
                 )
                 .collect(
                     Collectors.toList()
                 );

        System.out.println(names);
    }
}

map()

public class MapDemo {

    public static void main(String[] args) {

        List<String> names =
            List.of("Alice", "Bob");

        List<Integer> nameLengths =
            names.stream()
                 .map(String::length)
                 .collect(
                     Collectors.toList()
                 );

        System.out.println(nameLengths);
    }
}

distinct()

public class FlatMapDemo {

    public static void main(String[] args) {

        List<Integer> nums =
            List.of(1, 2, 2, 3);

        List<Integer> unique =
            nums.stream()
                .distinct()
                .collect(
                    Collectors.toList()
                );

        System.out.println(unique);
    }
}

flatMap()

public class DistinctDemo {

    public static void main(String[] args) {

        List<List<String>> data =
            List.of(
                List.of("a", "b"),
                List.of("c", "d")
            );

        List<String> flat =
            data.stream()
                .flatMap(List::stream)
                .collect(
                    Collectors.toList()
                );

        System.out.println(flat);
    }
}

sorted()

public class SortedDemo {

    public static void main(String[] args) {

        List<String> names =
            List.of(
                "John",
                "Alice",
                "Bob"
            );

        List<String> sorted =
            names.stream()
                 .sorted()
                 .collect(
                     Collectors.toList()
                 );

        System.out.println(sorted);
    }
}

limit()

public class LimitDemo {

    public static void main(String[] args) {

        List<Integer> limited =
            Stream.of(1, 2, 3, 4, 5)
                  .limit(3)
                  .collect(
                      Collectors.toList()
                  );

        System.out.println(limited);
    }
}

skip()

public class SkipDemo {

    public static void main(String[] args) {

        List<Integer> skipped =
            Stream.of(1, 2, 3, 4, 5)
                  .skip(2)
                  .collect(
                      Collectors.toList()
                  );

        System.out.println(skipped);
    }
}

18. Terminal Operations

peek()

public class PeekDemo {

    public static void main(String[] args) {

        List<String> result =
            List.of(
                "apple",
                "banana",
                "cherry"
            )
            .stream()
            .peek(
                System.out::println
            )
            .map(
                String::toUpperCase
            )
            .collect(
                Collectors.toList()
            );

        System.out.println(result);
    }
}

mapToInt()

public class MapToIntDemo {

    public static void main(String[] args) {

        int sum =
            List.of(
                "a",
                "bb",
                "ccc"
            )
            .stream()
            .mapToInt(String::length)
            .sum();

        System.out.println(sum);
    }
}

forEach()

List<String> names =
    Arrays.asList(
        "Alice",
        "Bob",
        "Charlie"
    );

names.stream()
     .forEach(
         System.out::println
     );

toArray()

String[] nameArray =
    names.stream()
         .toArray(String[]::new);

reduce()

List<Integer> numbers =
    Arrays.asList(
        1, 2, 3, 4
    );

int sum =
    numbers.stream()
           .reduce(
               0,
               Integer::sum
           );

collect()

List<String> list =
    names.stream()
         .collect(
             Collectors.toList()
         );

Set<String> set =
    names.stream()
         .collect(
             Collectors.toSet()
         );

String joined =
    names.stream()
         .collect(
             Collectors.joining(", ")
         );

min() and max()

Optional<Integer> min =
    numbers.stream()
           .min(
               Integer::compareTo
           );

Optional<Integer> max =
    numbers.stream()
           .max(
               Integer::compareTo
           );

count()

long count =
    names.stream().count();

anyMatch(), allMatch(), noneMatch()

boolean anyStartsWithA =
    names.stream()
         .anyMatch(
             s -> s.startsWith("A")
         );

boolean allHaveLength3 =
    names.stream()
         .allMatch(
             s -> s.length() == 3
         );

boolean noneStartsWithZ =
    names.stream()
         .noneMatch(
             s -> s.startsWith("Z")
         );

findFirst()

Optional<String> first =
    names.stream()
         .findFirst();

findAny()

Optional<String> any =
    names.parallelStream()
         .findAny();

forEachOrdered()

names.parallelStream()
     .forEachOrdered(
         System.out::println
     );

19. Custom Collector

The final example in the PDF demonstrates a custom Collector that uses StringJoiner to combine stream elements with a delimiter.

Collector<String, StringJoiner, String>
    customCollector =
        Collector.of(
            () ->
                new StringJoiner(" | "),
            StringJoiner::add,
            StringJoiner::merge,
            StringJoiner::toString
        );

String result =
    names.stream()
         .collect(customCollector);

Example output shown in the source:

Alice | Bob | Charlie

20. Quick Revision

Stream Pipeline Memory Trick