Stream

members
    .stream()
    .filter(
        p -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25)
    .map(p -> p.getEmailAddress())
    .forEach(email -> System.out.println(email));

• filter,
• map,
• forEach

• determines what collection it iterates
• and delegates how to iterate the collection to the JDK (internal iteration)

• A source: This could be :
  • a collection,
  • an array,
  • a generator function,
  • or an I/O channel.
• Zero or more intermediate operations. An intermediate operation, such as filter, produces a new stream.
• A terminal operation. A terminal operation, such as forEach, produces a non-stream result, such as:
  • a primitive value (like a double value), (such as average, sum, min, max, and count) - return one value by combining the contents of a stream - These operations are called reduction operations (Reduction operation doc
  • a collection,
  • or in the case of forEach, no value at all.

double average = members
    .stream() // create a stream of members
    .filter(p -> p.getGender() == Person.Sex.MALE) // return a stream of male person
    .mapToInt(Person::getAge) // return the age of each mal members in a new stream
    .average() // average them
    .getAsDouble(); // return it as double

 Stream.of(1, 2, 3, 4)
      .filter(e -> e > 2)
      .peek(e -> System.out.println("Peek: Value after the Filter stage: " + e))
      .map(e -> e + 1)
      .peek(e -> System.out.println("Peek: Value after the Mapped value: " + e))
      .collect(Collectors.toList());

Peek: Value after the Filter stage: 3
Peek: Value after the Mapped value: 4
Peek: Value after the Filter stage: 4
Peek: Value after the Mapped value: 5

• reduce
• collect,

Integer totalAgeReduce = roster
   .stream()
   .map(Person::getAge)
   .reduce(
       0,
       (a, b) -> a + b
   );

• 0 is the value of the identity argument. It is both:
  • the initial value of the reduction
  • and the default result if there are no elements in the stream.
• (a, b) → a + b is a lambda expression that defines the accumulator function where
  • a is the partial value of all processed elements so far (In this case, a sum)
  • b is the next element of the stream
  • and a+b is the operation that returns a partial result

• Return a list

stream
.map(Obj:FunctionThatReturnAList)
.collect(ArrayList::new, List::addAll, List::addAll);


List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add,ArrayList::addAll);

Function<String, String> helloOp = (s) -> "Hello " + s;
    Function<String, String> shoutedOp = (s) ->  s + " !!!";
    Function<String, String> helloShoutedOp = shoutedOp.compose(helloOp);
    String helloWorldShouted = helloShoutedOp.apply("World");
    System.out.println(helloWorldShouted);

Hello World !!!

try (IntStream stream = IntStream.range(1,10)) {
      stream.onClose(() -> System.out.println("--")).forEach(x -> System.out.println(x));
}