The Optional Type

• In Java, common to use null to denote absence of result
• Drawback: NullPointerException when programmer forgets to check

  String result = oldFashionedMethod(searchParameters);
     // Returns null if no match
  int length = result.length();
     // Throws a NullPointerException when result is null

• Stream library uses Optional type when a result may not be present.
• Example: First string of length > 10

  words.filter(w -> w.length() > 10).findFirst()

• What if there is none? An Optional<String> either contains a string or an indication that no value is present.

  Optional<String> optResult = words
     .filter(w -> w.length() > 10)
     .findFirst();

Working with Optional

• Work with it, not against it. (That is, don't treat it like a potentially null reference.)
• orElse extracts the value or an alternative if there is none:

  int length = optResult.orElse("").length();

• ifPresent passes on the value to a function; does nothing if there is none

  optResult.ifPresent(v -> results.add(v));

• If neither of these works, use isPresent to test if there is a value and get to get it.

  if (optResult.isPresent())
  {
     System.out.println(optResult.get());
  }
  else
  {
     System.out.println("No element");
  }

Your Turn

Which of these is the best way for searching for the first string containing an "e"?

1. String result = words
     .filter(w -> w.contains("e"))
     .findFirst()
     .orElse("None");
   

2. String result = words
     .filter(w -> w.contains("e"))
     .findFirst()
     .orElse("");
   

3. String result = words
     .filter(w -> w.contains("e"))
     .findFirst()
     .orElse(null);
   

4. Optional<String> result = words
     .filter(w -> w.contains("e"))
     .findFirst();
   

Returning Optional

• Declare return type as Optional<T>
• If there is a result, return Optional.of(result)
• Otherwise return Optional.empty()

• public static Optional<Double> squareRoot(double x)
  {
     if (x >= 0) { return Optional.of(Math.sqrt(x)); }
     else { return Optional.empty(); }
  }

Your Turn

Change this method so that it works for empty collections. Return an Optional result.

Other Terminal Operations

• findAny is like findFirst, but is faster on parallel streams.

  result = words
     .parallel()
     .filter(w -> w.length() > 10)
     .filter(w -> w.endsWith("y"))
     .findAny()
     .orElse("");

• max/min require a comparator and return an Optional (since the input may be empty):

  Optional<String> result = words.max((v, w) -> v.length() - w.length());

• allMatch/anyMatch/noneMatch check a predicate:

  boolean result = words.allMatch(w -> w.contains("e"));
  // result is true if all words contain the letter e

Primitive-Type Streams

• Inefficient to have streams of number wrappers such as Stream<Integer>
• For example, numbers.map(x -> x * x) requires unboxing and boxing for each element
• IntStream, DoubleStream, DoubleStream work with int, long, double values without boxing
• No stream classes for byte, short, long, char, float

Your Turn

Consider this code that operates on a Stream<Integer>:

long result = Stream.iterate(0, n -> n + 1)
   .limit(1000)
   .filter(n -> n % 2 == 0)
   .map(n -> n * 2)
   .count();

How many boxing and unboxing operations are necessary?

1. 3000
2. 3500
3. 4000
4. Something else

Creating Primitive-Type Streams

• Can create from individual numbers, or an array

  IntStream stream = IntStream.of(3, 1, 4, 1, 5, 9);
  int[] values = . . .;
  stream = IntStream.of(values);

• range yields a contiguous range of integers

  IntStream stream = IntStream.range(a, b);
     // Stream contains a, a + 1, a + 2, ..., b -1

• Random generator yields infinite stream of random numbers

  Random generator = new Random();
  IntStream dieTosses = generator.ints(1, 7);
  

• String yields stream of Unicode code points

  IntStream codePoints = str.codePoints();

  • Aside: This is the best way of getting the code points of a string in the Java API!
  • Much better than charAt which only yields 16-bit code units of the variable-length UTF-16 encoding

Mapping Primitive-Type Streams

• IntStream.map with an int -> int function yields another IntStream

  IntStream stream = IntStream.range(0, 20)
     .map(n -> Math.min(n, 10));
     // A stream with twenty elements 0, 1, 2, ..., 9, 10, 10, ..., 10

• When the function yields objects, use mapToObj:

  String river = "Mississippi";
  int n = river.length();
  Stream<String> prefixes = IntStream.range(0, n)
     .mapToObj(i -> river.substring(0, i));
     // "", "M", "Mi", "Mis", "Miss", "Missi", ...
  

• Also have mapToDouble, mapToLong if the function yields double, long values
• Think of IntStream.range(a, b).mapXXX as an equivalent of a for loop that yields a value in each iteration.
• Use mapToInt/mapToLong/mapToDouble with streams of objects when the map function yields primitive type values
• Use boxed to turn into a stream of objects

Your Turn

Complete this method to process a stream of strings and yield the distinct lengths (in increasing order). Pay attention to efficiency:

• Use an IntStream for the lengths
• Apply operations in an order that minimizes the cost

Processing Primitive-Type Streams

• Stream methods for primitive-type streams have modified parameters/return types
• For example, IntStream.toArray returns an int[] and doesn't require a constructor
• Four additional methods sum, average, max, min (without comparators)
• Last three return OptionalInt/OptionalLong/OptionalDouble

• double average = words
     .mapToInt(w -> w.length())
     .average()
     .orElse(0);

Exercises

1. Change this method so that it works with an Optional<Pair<Integer, Integer>>. For an empty Optional, return []. Do not use get.
2. Implement this method so that it returns a sorted string of distinct vowels. As before, use Normalizer.normalize(str, Normalizer.Form.NFD) to take off accents, but now do this first, then convert to a stream of code points. When you filter the vowels, use a method expression. To turn the result back into a string, use the constructor new String(cps, 0, cps.length), where cps is an int[] array of code points.
3. Complete this method that accepts an integer n and then yields all squares of the integers from 1 to n that are palindromes (that is, their decimal representation equals its reverse). Use IntStream.range, map or maybe mapToInt, filter, and toArray.
4. (Hard) Complete this method that removes all adjacent duplicates of a stream, by using a predicate that compares each element against the previous one (stashed away in an array of length 1), updates the array, and returns the result of the comparison. You have to be careful with the first element.