Stream termination

Finally output or aggregate the values processed / filtered by stream processing
** Streams are processed together with termination processing as a trigger **
Termination processing ** cannot be omitted **
cf: Intermediate processing can be omitted
Stream cannot be reused after termination (IllegalStateException)

Process elements in sequence

** forEach method **
In addition to passing the System.out :: println method reference as is, you can also pass it as a lambda expression.

import java.util.stream.Stream;
public class StreamForEach {
  public static void main(String[] args) {
    Stream.of("Munchkin", "Siamese", "Persian", "Tama")
    .forEach(v -> System.out.println(v));
  }
}

The forEach method ** does not guarantee order in parallel streams! ** **
→ Use the ** forEachOrdered method ** to keep the order!

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    Stream.of("Munchkin", "Siamese", "Persian", "Tama")
    .parallel()
    .forEach(v -> System.out.println(v));
    //Persian Tama Siamese Munchkin 
    
    /*If you want to keep the order
    .forEachOrdered(v -> System.out.println(v)); 
    Munchkin Siamese Persian Tama
    */
  }
}

Get the first value

** findFirst method **
The return value is ** Optional type ** because the stream may be empty

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {

    var str = Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .filter(s -> s.startsWith("S"))
        .findFirst();
      //If the orElse method is null"-"Replace with
      System.out.println(str.orElse("－")); //Siamese
  }
}

** The findAny method ** returns the first result obtained * in a parallel stream **, so the result may change.

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {

    var str = Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .parallel()
    .filter(s -> s.startsWith("S"))
    .findAny();
     System.out.println(str.orElse("－")); //Scottish Fold
  }
}

Determine if the value meets certain conditions

** anyMatch / allMatch / noneMatch method **

//Check if all the values in the list are 0 or more
import java.util.stream.IntStream;

public class StreamMatch {

  public static void main(String[] args) {
    System.out.println(
        IntStream.of(1, 10, 5, -5, 12)
          .allMatch(v -> v >= 0)
      ); //false
  }
}

Convert to array / collection

** toArray method **
Get stream processing result as a string array

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    var list = Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .filter(s -> s.startsWith("S"))
        .toArray();
    System.out.println(list[0]); //Siamese
  }
}

** Convert to collection with collect method **
Convert stream processing result to list
** toList **: Convert to list
** toSet **: Convert to set
** toMap **: Convert to map
** toCollection **: Convert to a general collection

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTrans2 {

  public static void main(String[] args) {
    var list = Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .filter(s -> s.startsWith("S"))
        .collect(Collectors.toList());
    System.out.println(list);
  }
}

** toMap method **
Set the merge argument if there is a possibility of duplication (IllegalStateException)

//Name the Person object array:Convert to map format of email address
public class StreamCollectMap {

  public static void main(String[] args) {
    System.out.println(
        Stream.of(
          new Person("Yamada Taro", "[email protected]"),
          new Person("Hanako Suzuki", "[email protected]"),
          new Person("Saburo Inoue", "[email protected]"),
          new Person("Kumi Sato", "[email protected]"),
          new Person("Yamada Taro", "[email protected]")
        ).collect(Collectors.toMap(
          //The argument key represents the key of the map
          Person::getName,
          //The argument value represents the key of the map
          Person::getEmail,
          //When there is a possibility of duplication
          (s, a) -> s + "/" + a
          //Overwrite value when duplicated
          // (s, a) ->  a
        ))
      );
  }
}

public class Person {
  private String name;
  private String email;
  public Person(String name, String email) {
    this.name = name;
    this.email = email;
  }
  public String getName() {
    return name;
  }
  public String getEmail() {
    return email;
  }
}

Find the maximum and minimum

** min.max method **
Comparator type as an argument
Sort by natural order
Since the return value is Optional type, ** orElse method ** to retrieve the value **

import java.util.Comparator;
import java.util.stream.Stream;

public class StreamMin {

  public static void main(String[] args) {
    var str = Stream.of("Rockfish", "pacific saury", "Flounder", "Sardines", "Atka mackerel")
        .min(Comparator.naturalOrder());
      System.out.println(str.orElse("")); //Sardines
  }
}

Find the number of elements

** count method **

//Find the number of strings larger than the string length 3.
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    System.out.println(
    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
      .filter(s -> s.length() > 7)
      .count() //2
    );
  }
}

Find the total / average value

** sum / average method **
Only available for basic streams
The return value of the average method is ** OptionalDouble type **
Extract with orElse method

//Int array sum, average
import java.util.stream.IntStream;

public class StreamSum {

  public static void main(String[] args) {
    var list = new int[] { 5, 1, 10, -3 };
    System.out.println(IntStream.of(list).sum()); //13
    System.out.println(IntStream.of(list).average().orElse(0)); //3.25
  }
}

Combine stream values into one

** Reduction **
The max / min / count method is also reduced
** Reduce method ** for general reduction

With one argument:

Arguments received by the reduce method (lambda expression)
** Variable for storing operation result ** (result)
** Variable to receive individual elements ** (str)

//Combine string streams separated by commas
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {

    System.out.println(
      Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .sorted()
        .reduce((result, str) -> {
          return result + "," + str;
        })
        .orElse("") //Munchkin,Persian,Scottish Fold,Siamese,Tama
    );
  }
}

With 2 arguments:

You can receive the initial value
The result is non-null, so it is non-Optional
Value can be obtained without going through orElse
In a parallel stream, the result changes because the initial value is applied to the lambda expression by the amount distributed.
There is a possibility of duplicate initial values due to parallelization

import java.util.stream.Stream;
public class StreamReduce2 {
  public static void main(String[] args) {
    System.out.println(
      Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .sorted()
        // .parallel()
        .reduce("Himalayan", (result, str) -> {
          return result + "," + str;
        })
    ); //Himalayan,Munchkin,Persian,Scottish Fold,Siamese,Tama
  }
}

With 3 arguments:

Used when Stream element type and ** final result type are different **
When getting individual elements with reduce, the operation result (result) and the variable (value) of each element are ** different types are OK **
Add the string value converted to a number to the argument result (Integer)

import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    System.out.println(
      Stream.of("153", "211", "112", "350", "418", "208")
        .parallel()
        .reduce(0,
          //Get individual elements
          //The operation result is stored in result, and value receives each element.
          (result, value) -> {
            return result + Integer.parseInt(value); //Convert string value to number
          },
          //Summarize the distributed results(Parallel stream only)
          (result1, result2) -> {
            return result1 + result2; //1452
          }
      )
    );
  }
}

Collect stream elements into a collection (1)

** collect method **
** Variable reduction **: Accumulates and returns values in a variable container (container) such as a collection or StringBuilder.
cf: reduce combines in-stream elements into a ** single type like int / String **

//Sort a given string stream and convert it to a list
import java.util.ArrayList;
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    System.out.println(
      Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama"
        .sorted()
        .collect(
          //Create a container that stores the value in the first value of reduction by the number of expressions
          ArrayList<String>::new,
          //Arguments are containers, individual elements
          (list, str) -> list.add(str),
          //For parallel streams
          (list1, list2) -> list1.addAll(list2)
        )
    );
  }
}

Collect stream elements into a collection (2)

** collect method has overload **
Can be generated with Collector.of static method
Collector attribute
** CONCURRENT **: Accumulator can be executed in multiple threads
** UNORDERED **: Do not guarantee the order of elements
** IDENTITY_FINISH **: finisher can be omitted

import java.util.ArrayList;
//import java.util.Arrays;
import java.util.stream.Collector;
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    System.out.println(
      Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
        .sorted()
        .collect(
          Collector.of(
            ArrayList::new,
            ArrayList::add,
            (list1, list2) -> {
              list1.addAll(list2);
              return list1;
            },
            Collector.Characteristics.IDENTITY_FINISH
          )
        )
    );
  }
}

Standard collector

The Collectors class has a factory method that creates a collector that can be used with the collect method.
** Easy implementation of typical redacification processing! ** **
ToList and toMap methods are also included in the factory method

joining method

Collecter generation of string concatenation

import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(Collectors.joining(",", "<", ">")) //<Munchkin,Persian,Scottish Fold,Siamese,Tama>
      );
  }
}

groupingBy method

Collector generation to group values by specified key

//Categorize strings by length
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(
          //Receive element type with argument str and generate grouping key
          //Group by string
            Collectors.groupingBy(str -> str.length()
          )) //{4=[Tama], 7=[Persian, Siamese], 8=[Munchkin], 13=[Scottish Fold]}
      );
  }
}

** Process the grouped results in another collector **
Argument specified for joining

public class Main {

  public static void main(String[] args) {
      
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(
            Collectors.groupingBy(
              str -> str.length(),
              Collectors.joining("/") //{4=Tama, 7=Persian/Siamese, 8=Munchkin, 13=Scottish Fold}
          ))
      );
  }
}

partitioningBy method

** Simple grouping split into true / false **

//Divide whether the character string is 7 characters or less or long
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
      
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(
            Collectors.partitioningBy(
              str -> str.length() > 7
          ) //{false=[Persian, Siamese, Tama], true=[Munchkin, Scottish Fold]}
        )
      );
  }
}

collectingAndThen method

Execution of termination processing after collector execution
Concatenate collector and post-processing

//List streams with toList method
//Collections::Convert to read-only with unmodifiableList

import java.util.Collections;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

  public static void main(String[] args) {
    System.out.println(
        Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
          .sorted()
          .collect(
            Collectors.collectingAndThen(
              Collectors.toList(),
              Collections::unmodifiableList
            )
          )
      );
  }
}

IntSummaryStatistics class

Get basic numerical statistics
The return value of the collect method is (Int) SummaryStatistics object
Get stats with getter method
** getAverage () **: Average value (0 if there is no value)
** getCount () **: Number of elements
** getMax () **: Maximum
** getMin () **: Minimum
** getSum () **: Total (0 if no value)

import java.util.IntSummaryStatistics;
import java.util.stream.IntStream;

public class Main {

  public static void main(String[] args) {
    var summary = IntStream.of(5, 13, 7, 2, 30)
      .collect(
     //Pass a reference to the parseInt sod in the constructor, accept, combineDB
        IntSummaryStatistics::new,
        IntSummaryStatistics::accept,
        IntSummaryStatistics::combine
      );
    System.out.println(summary.getMin()); //2
    System.out.println(summary.getSum()); //57
    System.out.println(summary.getAverage()); //11.4
  }
}

[Java] Stream API --Stream termination processing

Stream termination

Process elements in sequence

Get the first value

Determine if the value meets certain conditions

Convert to array / collection

Find the maximum and minimum

Find the number of elements

Find the total / average value

Combine stream values into one

With one argument:

With 2 arguments:

With 3 arguments:

Collect stream elements into a collection (1)

Collect stream elements into a collection (2)

Standard collector

** joining method **

** groupingBy method **

** partitioningBy method **

** collectingAndThen method **

** IntSummaryStatistics class **

joining method

groupingBy method

partitioningBy method

collectingAndThen method

IntSummaryStatistics class