OCP 17 Exam - chapter 10 notes

Streams fundamentals

• “Streams are evaluated lazily, which means intermediate operations are not executed until a terminal operation is invoked.”

    var ints = new ArrayList<Integer>();
    ints.add(1); 
    var intsStream = ints.stream();
    ints.add(2);
    System.out.println(intsStream.count()); // prints 2 !!
  

• “Streams are single-use; stream must have at most one terminal operation.” Exception will be thrown when terminal operation is called again on stream reference: (review Q.3)

    var stream = Stream.iterate(0, i -> i+1).limit(10);
    var m1 = stream.noneMatch(i -> i < 0);
    // var m2 = stream.anyMatch(i -> i > 5); // throws java.lang.IllegalStateException: stream has already been operated upon or closed
    var m2 = true;
    System.out.println(m1 + " | " + m2);
  

Note: java.util.Collection.parallelStream can be used to speedup processing of large stream with time-consuming operations.

Infinite streams

• infinite streams can be created with Stream#iterate or Stream#generate:

    Stream.iterate(1, i -> i + 1).limit(10)
        .forEach(i -> System.out.print(i +",")); // prints 1,2,3,4,5,6,7,8,9,10,
    System.out.println("");   
      
    Stream.iterate(1, i -> i <= 10, i -> i + 1)
        .forEach(i -> System.out.print(i +",")); // prints 1,2,3,4,5,6,7,8,9,10,   
    System.out.println("");    
      
    Stream.generate(() -> new Random().nextInt(10)).limit(10)
        .forEach(i -> System.out.print(i +",")); // prints random numbers 
    System.out.println("");  
  

infinite stream w/o stop (e.g. limit(10)) causes program hang! (review Q.2)

Note: only findFirst and findAny terminate infinite stream. Methods that sometimes terminates are: allMatch, anyMatch, noneMatch.

Reduce operations

• Stream#reduce - if you don’t specify identity parameter, then return type is Optional, see method signatures:

  T reduce(T identity, BinaryOperator<T> accumulator);
  Optional<T> reduce(BinaryOperator<T> accumulator);
  

• Stream#collect is called mutable reduction as we can accumulate an intermediate result, see method signature: ```java

R collect(Supplier supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner); ``` - parameters of `Stream#collect`: - `supplier` is used to initialize collection - `accumulator` adds elements to collection - `combiner` combines to collection - useful for parallel stream ## Primitive streams - all ways to create primitive stream: ```java var intStreamEmpty = IntStream.empty(); var intStreamOfValues = IntStream.of(1, 2, 3); var intStreamOfSingleValue = IntStream.of(1); var intStreamRange = IntStream.range(0, 10); var intStreamRangeClosed = IntStream.rangeClosed(0, 10); var intStreamIterateInfinite = IntStream.iterate(1, i -> i + 1); var intStreamGenerateInfinite = IntStream.generate(new Random()::nextInt); var intStreamUnboxed = Stream.of(1, 2, 3).mapToInt(Integer::intValue); ``` - remember that return type of `average` is `OptionalDouble`, whereas `IntSummaryStatistics#getDouble` returns `double` with `0` when empty stream (review Q.8): ```java OptionalInt optionalInt = IntStream.empty().findFirst(); int sum = IntStream.empty().sum(); OptionalDouble optionalDouble = IntStream.empty().average(); if(optionalDouble.isPresent()) { System.out.println(optionalDouble.getAsDouble()); } System.out.println(IntStream.empty().summaryStatistics().getAverage()); // prints 0.0 // prints IntSummaryStatistics{count=3, sum=6, min=1, average=2.000000, max=3} System.out.println(intStreamOfValues.summaryStatistics()); ``` # Playground code <https://github.com/RG9/rg-playground-ocp17/blob/main/Chapter10.java> ---- Credit: [OCP Oracle Certified Professional Java SE 17 Developer Study Guide](https://www.selikoff.net/ocp17)