[Java] Stream API --Stream intermediate processing

Stream intermediate processing

• Process and filter the values flowing through the stream
• It is executed ** when the termination process is called **

Filter values by specified conditions

• ** filter method **

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    Stream.of(
      "https://qiita.com/",
      "Neko",
      "CAT",
      "https://www.amazon.co.jp/",
      "https://ja.wikipedia.org/wiki/Neko_(%E3%82%BD%E3%83%95%E3%83%88%E3%82%A6%E3%82%A7%E3%82%A2)"
    )
      .filter(s -> s.startsWith("https://"))
      .forEach(System.out::println);
/*
https://qiita.com/
https://www.amazon.co.jp/
https://ja.wikipedia.org/wiki/Neko_(%E3%82%BD%E3%83%95%E3%83%88%E3%82%A6%E3%82%A7%E3%82%A2)
*/
  }
}

Process the given value

• ** map method **
• Convert string list to string length list and output
• Immediately after it is generated, it becomes String <String>, and after passing through the map method, it becomes String <Integer>.

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

    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .map(s -> s.length())
    .forEach(System.out::println); //8 7 7 13 4
  }
}

• Generate basic type stream ** mapToInt / mapToLong / mapToDouble method **
• Generates IntStream instead ofString <Integer>
• Reduced boxing burden

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .mapToInt(s -> s.length())
    .forEach(System.out::println); //8 7 7 13 4
  }
}

Process a given element

• ** flatMap / flatMapToXX method **
• The difference from map is that the conversion result is ** returned as Stream type **
• Streams returned by individual elements are finally combined and returned

//Convert 2D array list to 1D array
import java.util.Arrays;
public class Main {
  public static void main(String[] args) {

    var list = new String[][] {
      { "neko", "nekko", "nekkko" },
      { "inu", "innu" },
      { "tori", "torri" }
    };
    //Pass a nested array with flatMap and Arrays.Stream with stream method
    //Flatten to a one-dimensional array by connecting with flatMap
    Arrays.stream(list)
      .flatMap(v -> Arrays.stream(v))
      .forEach(System.out::println);
     // neko nekko nekkko inu innu tori torri
    }
}

• It is also possible to process values by nesting during stream processing **

//Extract acronyms when flattening a two-dimensional array
import java.util.Arrays;
public class Main {
  public static void main(String[] args) {

    var list = new String[][] {
      { "neko", "nekko", "nekkko" },
      { "inu", "innu" },
      { "tori", "torri" }
    };

    Arrays.stream(list)
    .flatMap(v -> Arrays.stream(v).map(str -> str.substring(0, 1)))
    .forEach(System.out::println);
    //n n n i i t t
    }
}

Sort elements

• ** sorted method **
• Sort by natural order

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

    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .sorted()
    .forEach(System.out::println);
// Munchkin
// Persian
// Scottish Fold
// Siamese
// Tama
  }
}

• If you want to set a rule, ** set it with a lambda expression **

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

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

    Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
    .sorted((str1, str2) -> str1.length() - str2.length())
    .forEach(System.out::println);
    // Tama
    // Siamese
    // Persian
    // Munchkin
    // Scottish Fold

    /*Dictionary reverse order in Comparator interface
     Stream.of("Munchkin", "Siamese", "Persian", "Scottish Fold", "Tama")
     .sorted(Comparator.reverseOrder())
     .forEach(System.out::println);
    */
  }
}

Extract the m ~ nth element

• ** skip / limit method **
• ** skip method **: Truncate up to mth element
• ** limit method **: truncates the n + 1th and subsequent elements

//Use skip to skip 4 elements, and limit to extract 10 elements from it.
import java.util.stream.IntStream;
public class StreamLimit {
  public static void main(String[] args) {
    IntStream.range(1, 20)
      .skip(4)
      .limit(10)
      .forEach(System.out::println); //5,6,7,8,9,10,11,12,13,14
  }
}

Remove values from the beginning while satisfying the conditions

• ** dropWhile method **
• Skip values that match the conditional expression
• Remove negative numbers from the beginning of the stream
• To the last ** Since it is a continuous value from the beginning, negative numbers in the middle are not removed **
• → If in the middle, remove with filter

import java.util.stream.IntStream;
public class StreamDrop {
  public static void main(String[] args) {
    IntStream.of(-2, -5, 0, 3, -1, 2)
      .dropWhile(i -> i < 0)
      .forEach(System.out::println); //0,3,-1,2
  }
}

Extract only the values that satisfy the conditions from the beginning

• ** takeWhile method **
• Process only those that are negative from the beginning of the stream
• To the last ** Processing is a continuous value from the beginning **

import java.util.stream.IntStream;
public class StreamTake {
  public static void main(String[] args) {
    IntStream.of(-2, -5, 0, 3, -1, 2)
      .takeWhile(i -> i < 0)
      .forEach(System.out::println); //-2,-5
  }
}

Check the middle status of the stream

• ** peek method **
• Arbitrary processing can be inserted in the middle
• The peek method ** does not affect the stream **

//Output stream contents before and after sorting
import java.util.stream.Stream;
public class StreamPeek {
  public static void main(String[] args) {
    Stream.of("Fish", "Grime", "echo", "Kinmokusei")
      .peek(System.out::println)
      .sorted()
      .forEach(System.out::println);
  }
}

Remove duplicate values

• ** distinct method **
• Remove duplication of values contained in the stream
• Cannot deduplication using a specific field of any class as a key
• → Use the filter method

import java.util.stream.Stream;
public class Main {
  public static void main(String[] args) {
    Stream.of("Cat", "Cat", "Nekko", "Cat", "CatCat")
      .distinct()
      .forEach(System.out::println);
    //Cat
    //Cat
    //Nekko
    //cat Cat
  }
}

• Check for duplicates using the name field as a key in the Person class

import java.util.HashSet;
import java.util.stream.Stream;

public class StreamDistinctObj {

  public static void main(String[] args) {
    var set = new HashSet<String>();
    Stream.of(
        new Person("Yamada", 40),
        new Person("Takano", 30),
        new Person("Okawa", 35),
        new Person("Yamada", 45)
      )
      //Add value to HashSet in filter method
      //HashSet.add method returns false if the value could not be added (duplicate)

      .filter(p -> set.add(p.name))
      .forEach(System.out::println);
  }
}

public class Person {
  public String name;
  public int age;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  @Override
  public String toString() {
    return String.format("%s（%d years old)", this.name, this.age);
  }
}

Basic stream conversion

• ** Type conversion with asLongStream / asDoubleStream / LongStream **

//Conversion from IntStream to DoubleStream
import java.util.stream.IntStream;
public class Main {
  public static void main(String[] args) {
    IntStream.range(1, 5)
      .asDoubleStream()
      .forEach(System.out::println);
      //1.0 2.0 3.0 4.0
  }
}

Mutual conversion between basic type and reference type streams

• From basic type to reference type: ** boxed method **
• Reference type to base type: ** mapToObj method **

//From IntStream to Stream<Integer>Conversion to
import java.util.stream.IntStream;
public class Main {
  public static void main(String[] args) {
    IntStream.range(1, 5)
      .boxed()
      .forEach(System.out::println);
      //1 2 3 4
      
    IntStream.range(1, 5)
      .mapToObj(Integer::valueOf)
      .forEach(System.out::println);
      //1 2 3 4
  }
}

//Stream<Integer>Convert to IntStream
import java.util.stream.Stream;
public class StreamUnboxed {
  public static void main(String[] args) {
    Stream.of(1, 2, 3, 4)
      .mapToInt(i -> i) //Unboxing Integer → int
      .forEach(System.out::println); //1 2 3 4
    }
}