Short-circuiting terminal operations (1)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> twoEvenSquares = 
    numbers.stream()
           .filter(n -> {
                    System.out.println("filtering " + n); 
                    return n % 2 == 0;
                  })
           .map(n -> {
                    System.out.println("mapping " + n);
                    return n * n;
                  })
           // Short-circuiting operation
           .limit(2)
           .collect(toList());

// Result
filtering 1
filtering 2
mapping 2
filtering 3
filtering 4
mapping 4

Short-circuiting terminal operations (2)

• findFirst / findLast
• single / findSingle
• anyMatch
• allMatch
• findIndexed
• limit
• ...

com.annimon.stream.Stream.java -> Ctrl + F -> "short-circuiting"

For Android

How do operators work?

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> eventNumbers = Stream.of(numbers)
                .filter(n -> {
                        System.out.println("filtering " + n);
                        return n % 2 == 0;
                 })
                .limit(2)
                .collect(Collectors.<Integer>toList());

1. Stream.of(numbers) - creates iterator
2. .filter() - new Stream(new ObjFilter(iterator))
3. limit - new Stream(new ObjLimit(iterator))
4. collect() -> calls 3.next() -> calls 2.next() -> calls 1.next()

1. ObjFilter extends Iterator
2. ObjLimit extends Iterator and adds maxSize state

Examples - Stream.

• of(Iterable) ...
• ofNullable(Iterable) ...
• range(from, to) ...
• zip(stream1, stream2, function) - combines
• merge(stream1, stream2, function) - picks values
• generate(Supplier) - generate custom values

Examples - Operators (1)

List<String> words = new ArrayList() {{
  add("Word");
  add("Paper");
  add("Word");
  add("Android Rulez");
  add("Device Information");
}};

Long distinctWords = 
  Stream.of(words)
    .distinct()
    .collect(Collectors.counting());

distinct

Long oneWordCount = 
  Stream.of(words)
    .filter(p -> p.split(" ").length == 1)
    .collect(Collectors.counting());

filter

String indexedSequence = 
  Stream.of(words)
    .indexed()
    .map(x -> String.format("%s %s ", x.getFirst(), x.getSecond()))
    .collect(Collectors.counting());
// 0 Word 1 Paper 2 Word 3 Android Rulez 4 Device Information 

indexed

Example - Operators (2)

Stream.of(words)
  .sortBy(String::length)
  .collect(Collectors.toList())

Sorting

Stream.of(words)
  .sorted(Comparator)
  .collect(Collectors.toList())

takeWhile / dropWhile / chunkBy

Stream.of("a", "b", "cd", "ef", "g")
    .takeWhile(s -> s.length() == 1) // [a, b]

Stream.of("a", "b", "cd", "ef", "g")
    .dropWhile(s -> s.length() == 1) // [cd, ef, g]

Stream.of("a", "b", "cd", "ef")
    .chunkBy(String::length) // [[a, b], [cd, ef]]

Example - Operators (3)

 filterNot / withoutNulls

map-filter-takeWhile-forEach*Indexed

Stream.of("a", "b", "c")
    .mapIndexed((i, s) -> s + Integer.toString(i)) // [a0, b1, c2]

stream.filterNot(String::isEmpty)

Stream.of("a", null, "c", "d", null)
    .withoutNulls() // [a, c, d]

average / sum

stream
  .mapToDouble(w -> w.getTranslate().length())
  .average() // only in mapToDouble

stream
  .mapToInt(w -> w.getTranslate().length())
  .sum()

Custom Operator

.custom()

Collectors (1)

Collectors (2)

You can use Collectors to transform data into different types of structures like from List to Map etc.

TreeMap<String, List<PaymentResponse>> map = 
  Stream.of(sortedPayments)
    .collect(
             Collectors.groupingBy(PaymentResponse::getAccountId, 
                                   TreeMap::new, 
                                   Collectors.toList())
    );

Custom Implementation

AdapterCollector