[Java] Stream API-Stream generation

What is the Steam API?

• ** Library that supports iterative processing **
• Extract elements from a set of data (data source) such as collections, arrays, and fals and pass them to the process flow (Stream).

Stream API basics

• ** Stream generation from data source **
• ** Intermediate processing ** (extraction, processing, etc.)
• The return value is Stream <T>
• ** Termination processing ** (output, aggregation, etc.)
• Stream series processing is executed at the timing of termination processing (delayed processing)
• Intermediate / termination processing can refer to the standard library that matches the type.
• ** Method chain **: Intermediate / termination processing can be concatenated from stream generation with . operator

import java.util.ArrayList;
import java.util.Arrays;

public class StreamBasic {

//Data source preparation
  public static void main(String[] args) {
    var list = new ArrayList<String>(Arrays.asList("ant", "elephant", "hamster"));

/*Processing by stream
Stream generation from a pre-prepared list
ArrayList<String>Because it is based on
stream method is also Stream<String>Returns an object
*/
    list.
      stream().
      /*Intermediate processing
Extract 3 or more characters with the filter method and convert to uppercase with map
The return value is Stream<T>
      */
      filter(s -> s.length() > 3).
      map(String::toUpperCase).
      /*Termination
System the value given by the forEach method.out
      */
      forEach(System.out::println);//ELEPHANT HAMSTER
  }
}

Stream generation

** Stream generation from collections and arrays **

• Lists, arrays, and map contents can be output by stream processing.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class StreamBasic2 {

//list
  public static void main(String[] args) {
    var list = new ArrayList<String>(Arrays.asList("ant", "elephant", "hamster"));
    list.stream().forEach(System.out::println);
    // list.parallelStream().forEach(System.out::println);
    System.out.println("---------------");

//Array
    var data = new String[] { "rose", "Morning glory", "Tulips" };
    Arrays.stream(data).forEach(System.out::println);
    System.out.println("---------------");

//map
    var map = new HashMap<String, String>(
        Map.of("orange", "Mandarin orange", "apple", "Apple", "strawberry", "Strawberry"));
    map.entrySet().stream().forEach(System.out::println);
  }
}

• ** parallelStream ** Parallel version of stream method
• If it is a collection of list maps, parallel processing will be possible if stream is changed to parallelStream.
  • list.parallelStream().forEach(System.out::println)

** Stream generation from arguments / lambda expressions **

• Factory method for Stream generation

** of method **

• ** Convert the specified variadic argument to a stream **

import java.util.stream.Stream;

public class StreamOf {
  public static void main(String[] args) {
    var stream = Stream.of("first", "second", "third");
    stream.forEach(System.out::println); //first, second, third
  }
}

** generate method **

• ** Stream generation with the specified lambda expression return **
• ex: Generate and stream random numbers from 1 to 100
• Since an infinite stream is generated, it is explicitly interrupted in intermediate / termination processing.
• In the following example, limit (10) processes only the first 10 cases.
• Random.ints method when generating a random number stream in the app

import java.util.Random;
import java.util.stream.Stream;

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

    var stream = Stream.generate(() -> {
      var r = new Random();
      return r.nextInt(100);
    });
    stream.limit(10).forEach(System.out::println);
    //46 24 42 80 61 67 69 22 85 1
  }
}

** iterate method **

• ** Stream generation with specified initial value and lambda expression **
• The initial value is passed first, and the previous result is passed after that.
• In the following example, 1 is set as the initial value and a value that is doubled is generated.

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    var stream = Stream.iterate(1, (num) -> {
      return num * 2;
    });
    stream.limit(10).forEach(System.out::println);
    //4 8 16 32 64 128 256 512
    }
}

** builder method **

• Stream.Builder object for stream assembly Sincerity

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    var builder = Stream.builder()
        .add("Munchkin")
        .add("Siamese")
        .add("Persian");
      builder.build().forEach(System.out::println); 
      //Munchkin
      //Siamese
      //Persian
  }
}

** concat method **

• ** Combine multiple streams into one stream for convenience **

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {

    var stream1 = Stream.of("Munchkin", "Siamese", "Persian");
    var stream2 = Stream.of("Corgi", "Poodle", "Shiba");
    Stream.concat(stream1, stream2).forEach(System.out::println);
    // Munchkin Siamese Persian 
    // Corgi Poodle Shiba
  }
}

** Generate basic stream **

• Specialized for basic types ** IntStream / LongStream / DoubleStream **
• ** of / generate / iterate / builder factory method ** can be used
• IntStream / LongStream can use ** range method **

//Upper limit A h Not included in the stream
import java.util.stream.IntStream;
public class Main {
  public static void main(String[] args) {
    IntStream.range(10, 20)
      .forEach(System.out::println); //10 11 12 13 14 15 16 17 18 19
  }
}

• If you want to include the upper limit, ** rangeClosed method **

import java.util.stream.IntStream;
public class Main {
  public static void main(String[] args) {
    IntStream.rangeClosed(10, 20)
     .forEach(System.out::println); //10 11 12 13 14 15 16 17 18 19 20
  }
}