The Stream Concept

• Algorithm for counting matches:

  List<String> wordList = . . .; long count = 0;
  for (String w : wordList)
  {
     if (w.length() > 10) { count++; }
  }

• With the Java 8 stream library:

  Stream<String> words = . . .;
  long count = words
     .filter(w -> w.length() > 10)
     .count();

• You tell what you want to achieve (Keep the long strings, count them)
• You don't dwell on the how (visit each element in turn, if it is long, increment a variable)
• "What, not how" is powerful:
  • Operations can occur in parallel
  • The data can be anywhere (e.g. distributed "big data")

Some Facts About Streams

• Streams are similar to collections, but...
• They don't store their own data
  • The data comes from elsewhere
  • From a collection, a file, a database, data from the internet, ...
• Streams were designed to work well with lambda expressions

  stream.filter(w -> w.length() > 10)

• Streams are immutable
  • Methods such as filter produce new streams
• Stream processing is lazy—see the next slide

Lazy Processing

• Instead of counting the words, let's see some (but not all)
• Here is how to get the first five:

  Stream<String> fiveLongWords = words
     .filter(w -> w.length() > 10)
     .limit(5);

• Dumb approach: first generate all long words, and throw most of them away.
• Fortunately, stream processing is not dumb but lazy
  • Works “backwards” and only computes what is necessary.
• limit(5) needs an element...
• ... and filter(....) examines elements until it finds one.
• That repeats another four times.
• And then...nothing.
• The other stream elements never get examined.

Producing Streams

• In order to process streams, you first need to have one
• Simplest way: the of method

  Stream<String> words = Stream.of("Mary", "had", "a", "little", "lamb");
  Stream<Integer> digits = Stream.of(3, 1, 4, 1, 5, 9);

• Also works for arrays:

  Integer[] digitArray = { 3, 1, 4, 1, 5, 9 };
  Stream<Integer> digitStream = Stream.of(digitArray);

  • This is a stream of Integer objects
  • You'll see later how to make a stream of int
• Any collection can be turned into a stream:

  List<String> wordList = new ArrayList<>();
  // Populate wordList
  Stream<String> words = wordList.stream();

Producing Streams 2

• Several utility methods yield streams:

  String filename = . . .;
  try (Stream<String> lineStream = Files.lines(Paths.get(filename)))
  {
     ...
  } // File is closed here
  

• You can make infinite streams:

  Stream<Integer> integers = Stream.iterate(0, n -> n + 1);

Your Turn

In this program, complete the methods that yield

• For a given sentence, the stream of all strings of length 1 in it. (Hint: s.split("") is an array of them.)
• The infinite stream containing *, **, ***, ****, ...

Collecting Results 1

• When you are done transforming a stream (e.g. with filter), want to harvest results
• Some methods (e.g. count, sum) yield a single value
• Other methods yield a collection
• Here is how to collect into an array:

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

  • Strange-looking expression String[]::new is a constructor reference (to the array constructor)
  • Replace String with another class if the stream doesn't contain strings

Collecting Results 2

• To collect into a List or Set, use collect:

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

  • The argument to collect is a Collector object
  • We'll always use one of the static method of Collectors to get one
• A stream of string can be collected into a single string:

  String result = words.collect(Collectors.joining(", "));
     // Stream elements separated with commas

Your Turn

Complete the method in this program that collects the first n strings of length ≤ maxLength from the collection c in a Set<String> (which might have fewer than n elements after discarding duplicates). Use streams.

Tip: One Stream Operation Per Line

• It's best to put one stream operation per line:

  List<String> result = list.stream() // Create the stream
     .filter(w -> w.length() > 10) // Keep long strings
     .limit(50) // Keep only the first fifty.
     .collect(Collectors.toList()); // Turn into a list

• If you cram as much as possible into one line, it is tedious to figure out the steps:

  List<String> result = list.stream().filter(w -> w.length() > 10).limit(50).collect(
     Collectors.toList()); // Don’t use this formatting style
  

Stream Tranformations: map

• Life cycle of a stream:
  • Create stream
  • Transform stream (possibly multiple times)
  • Collect results
• map transforms stream by applying function to each element
  • Turn all words into lowercase:

    Stream<String> words = Stream.of("A", "Tale", "of", "Two", "Cities");
    Stream<String> lowerCaseWords = words.map(w -> w.toLowerCase());
       // "a", "tale", "of", "two", "cities"

  • Remove vowels from all words:

    Stream<String> consonantsOnly = lowerCaseWords.map(
       w -> w.replaceAll("[aeiou]", ""));
       // "", "tl", "f", "tw", "cts"

  • Get the length of each element:

    Stream<Integer> consonantCount = consonantsOnly.map(w -> w.length()); // 0, 2, 1, 2, 3

Your Turn

Which of the following yields a stream of all words that start with a or A, converted to lowercase?

Stream<String> result = words
   .filter(w -> w.substring(0, 1).equalsIgnoreCase("a"))
   .map(w -> w.toLowerCase());

Stream<String> result = words
   .map(String::toLowerCase)
   .filter(w -> w.substring(0, 1).equals("a"));

1. Only the first
2. Only the second
3. Both, but the first is more efficient
4. Both, but the second is more efficient

More Stream Transformations

• Applying map yields a stream with the same number of elements
• filter only retains matching elements:

  Stream<String> aWords = words.filter(w -> w.substring(0, 1).equals("a"));
     // Only the words starting with "a"

• limit takes the first n:

  Stream<String> first100aWords = aWords.limit(100);

• skip takes all but the first n:

  Stream<String> allButFirst100aWords = aWords.skip(100);

• distinct yields a stream with duplicates removed:

  Stream<String> words = Stream.of(
     "how much wood could a wood chuck chuck".split(" "));
  Stream<String> distinctWords = words.distinct();
     // "how", "much", "wood", "could", "a", "chuck"

• sorted yields a new stream in which the elements are sorted:

  Stream<String> sortedWords = distinctWords.sorted();
     // "a", "chuck", "could", "how", "much", "wood"

  • Element type must be Comparable
  • Or supply a comparator: distinctWords.sorted((s, t) -> s.length() - t.length())

Common Error: Don't Use a Terminated Stream

• Once you apply a terminal operation, a stream is “used up”
• Can no longer apply any stream operations
• Easy mistake if you have a reference to an intermediate stream:

  Stream<String> stream = list.stream();
  List<String> result1 =  stream.limit(50).collect(Collectors.toList());
     // Save the first fifty
  stream = stream.skip(50);
     // Error—the stream can no longer be used

• To avoid the error, use “pipeline notation”

  result = create(...)
     .transform1(...)
     .transform2(...)
     .terminalOperation(...)

List<String> result1 = list.stream()
   .limit(50)
   .collect(Collectors.toList()); // This stream can no longer be used
List<String> result2 = list.stream() // Create another stream
   .skip(50)
   .limit(50)
   .collect(Collectors.toList());

Exercises

1. We want to count the distinct vowels in a word. This is easy with streams. Turn a word into a stream of single-letter strings (as before, with s.split("")). Filter out the vowels. (Use "aeiou".contains(c)...) and count the distinct ones.
   But what about accents? Strip them off, using this code:

   Normalizer.normalize(c, Normalizer.Form.NFD).substring(0, 1)

   The “normalization form D” (decomposition) takes an accented character such as ô and decomposes it into an o and the accent ^”
   Complete this program.
2. Now read in all words from a given file and find how many of them have five distinct vowels. Then list the twenty shortest ones. Complete this program.
   You have the static Words.distinctVowels method at your disposal. (It is hidden so as not to give away the answer to the previous exercise.)
3. (Hard) For each word in a stream, determine the “vowelness”, i.e. the number of vowels - the number of consonants. Produce the n words with the highest vowelness paired with the vowelness value. Sort first by vowelness, then by the string. Complete this program.
   This time, you have a hidden static method long Words.vowels(String w) at your disposal that yields the number of vowels in w, including duplicates.