[JAVA] - Stream API 기본 문법 및 활용 예제

Stream API 기본 문법 및 활용 예제

Stream 생성

• Stream은 Collection, List, Set, Array 등의 자료구조로부터 생성될 수 있습니다.

1. Collection으로 생성

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------Collection Stream 생성---------");
    CreateStream1 createStream1 = new CreateStream1();
    createStream1.createStream();
  }
}

class CreateStream1 {
  public void createStream() {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> stream = list.stream();

    stream.forEach(System.out::println);
  }
}

/*
---------Collection Stream 생성---------
java
spring
springBoot
jpa
queryDSL
*/

---

2. Array로 생성

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------Array Stream 생성---------");
    CreateStream2 createStream2 = new CreateStream2();
    createStream2.createStream();
  }
}

class CreateStream2 {
  public void createStream() {
    String[] arr = {"java", "spring", "springBoot", "jpa", "queryDSL"};
    Stream<String> stream = Arrays.stream(arr);

    stream.forEach(System.out::println);
  }
}

/*
출력
---------Array Stream 생성---------
java
spring
springBoot
jpa
queryDSL
*/

---

3. Stream.of() 이용

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------Stream.of Stream 생성---------");
    CreateStream3 createStream3 = new CreateStream3();
    createStream3.createStream();
  }
}

class CreateStream3 {
  public void createStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");

    stream.forEach(System.out::println);
  }
}

/*
출력
---------Stream.of Stream 생성---------
java
spring
springBoot
jpa
queryDSL
*/

---

Stream 중간 연산

• Stream에 대해서 중간 연산을 수행할 수 있습니다. 중간 연산은 Stream을 반환하기 때문에, 여러 개의 중간 연산을 연결하여 사용할 수 있습니다.

1. filter()

• 조건에 맞는 요소만을 선택하여 Stream으로 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------filter Stream 중간 연산---------");
    IntermediateOperationStream1 intermediateOperationStream1 = new IntermediateOperationStream1();
    intermediateOperationStream1.IntermediateOperationStream();
  }
}

class IntermediateOperationStream1 {
  public void IntermediateOperationStream() {
    System.out.println("filter 조건 : 원소 중 길이 5 이상인 원소 출력");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> filterStream = stream.filter(str -> str.length() > 5);

    filterStream.forEach(System.out::println);
  }
}

/*
출력
---------filter Stream 중간 연산---------
filter 조건 : 원소 중 길이 5 이상인 원소 출력
spring
springBoot
queryDSL
*/

---

2. map()

• 각 요소에 대해 매핑 함수를 적용하여 새로운 Stream을 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------map Stream 중간 연산---------");
    IntermediateOperationStream2 intermediateOperationStream2 = new IntermediateOperationStream2();
    intermediateOperationStream2.IntermediateOperationStream();
  }
}

class IntermediateOperationStream2 {
  public void IntermediateOperationStream() {
    System.out.println("map 조건 : 각 원소 길이만 출력");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<Integer> mapStream = stream.map(String::length);

    mapStream.forEach(System.out::println);
  }
}

/*
출력
---------map Stream 중간 연산---------
map 조건 : 각 원소 길이만 출력
4
6
10
3
8
*/

---

3. flatMap()

• 각 요소에 대해 매핑 함수를 적용하여 새로운 Stream을 생성하고, 이를 하나의 Stream으로 병합하여 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------flatMap Stream 중간 연산---------");
    IntermediateOperationStream3 intermediateOperationStream3 = new IntermediateOperationStream3();
    intermediateOperationStream3.IntermediateOperationStream();
  }
}

class IntermediateOperationStream3 {
  public void IntermediateOperationStream() {
    System.out.println("flatMap 조건 : 두 Stream을 새롭게 생성하고 하나의 Stream으로 병합");
    Stream<List<Integer>> stream = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4));
    Stream<Integer> flatMapStream = stream.flatMap(Collection::stream);

    flatMapStream.forEach(System.out::println);
  }
}

/*
출력
---------flatMap Stream 중간 연산---------
flatMap 조건 : 두 Stream을 새롭게 생성하고 하나의 Stream으로 병합
1
2
3
4
*/

---

4. sorted()

• 요소를 정렬하여 Stream으로 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------sorted Stream 중간 연산---------");
    IntermediateOperationStream4 intermediateOperationStream4 = new IntermediateOperationStream4();
    intermediateOperationStream4.IntermediateOperationStream();
  }
}

class IntermediateOperationStream4 {
  public void IntermediateOperationStream() {
    System.out.println("sort 조건 : 기본(오름차순) 정렬");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> sortStream = stream.sorted();

    sortStream.forEach(System.out::println);
  }
}

/*
출력
---------sorted Stream 중간 연산---------
sort 조건 : 기본(오름차순) 정렬
java
jpa
queryDSL
spring
springBoot
*/

---

5. distinct()

• 중복된 요소를 제거한 Stream을 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------distinct Stream 중간 연산---------");
    IntermediateOperationStream5 intermediateOperationStream5 = new IntermediateOperationStream5();
    intermediateOperationStream5.IntermediateOperationStream();
  }
}

class IntermediateOperationStream5 {
  public void IntermediateOperationStream() {
    System.out.println("distinct 조건 : 중복 요소 제거");
    Stream<String> stream = Stream.of("java", "java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> distinctStream = stream.distinct();

    distinctStream.forEach(System.out::println);
  }
}

/*
출력
---------distinct Stream 중간 연산---------
distinct 조건 : 
java
spring
springBoot
jpa
queryDSL
*/

---

6. limit()

• 처리할 요소의 개수를 제한하여 Stream을 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------limit Stream 중간 연산---------");
    IntermediateOperationStream6 intermediateOperationStream6 = new IntermediateOperationStream6();
    intermediateOperationStream6.IntermediateOperationStream();
  }
}

class IntermediateOperationStream6 {
  public void IntermediateOperationStream() {
    System.out.println("limit 조건 : 입력한 파라미터 만큼만 출력");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> limitStream = stream.limit(3);

    limitStream.forEach(System.out::println);
  }
}

/*
출력
---------limit Stream 중간 연산---------
java
spring
springBoot
*/

---

7. skip()

• 처리할 요소의 개수를 건너뛰고, 나머지 요소로 구성된 Stream을 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------skip Stream 중간 연산---------");
    IntermediateOperationStream7 intermediateOperationStream7 = new IntermediateOperationStream7();
    intermediateOperationStream7.IntermediateOperationStream();
  }
}

class IntermediateOperationStream7 {
  public void IntermediateOperationStream() {
    System.out.println("입력한 파리미터 만큼 건너뛰고 출력");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> skip = stream.skip(3);

    skip.forEach(System.out::println);
  }
}

/*
출력
---------skip Stream 중간 연산---------
jpa
queryDSL
*/

---

Stream 최종 연산

• Stream에 대해서 최종 연산을 수행할 수 있습니다. 최종 연산은 Stream을 반환하지 않고, 최종 결과를 반환합니다.

1. forEach()

• 각 요소에 대해 작업을 수행합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------forEach Stream 최종 연산---------");
    FinalOperationStream1 finalOperationStream1 = new FinalOperationStream1();
    finalOperationStream1.FinalOperationStream();
  }
}

class FinalOperationStream1 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");

    stream.forEach(System.out::println);
  }
}

/*
출력
---------forEach Stream 최종 연산---------
java
spring
springBoot
jpa
queryDSL
*/

---

2. toArray()

• Stream의 요소를 배열로 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------toArray Stream 최종 연산---------");
    FinalOperationStream2 finalOperationStream2 = new FinalOperationStream2();
    finalOperationStream2.FinalOperationStream();
  }
}

class FinalOperationStream2 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");

    String[] toArrayStream = stream.toArray(String[]::new);
    System.out.println(Arrays.toString(toArrayStream));
  }
}

/*
출력
---------toArray Stream 최종 연산---------
[java, spring, springBoot, jpa, queryDSL]
*/

---

3. reduce()

• Stream의 요소를 하나로 줄여 하나의 결과를 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------reduce Stream 최종 연산---------");
    FinalOperationStream3 finalOperationStream3 = new FinalOperationStream3();
    finalOperationStream3.FinalOperationStream();
  }
}

class FinalOperationStream3 {
  public void FinalOperationStream() {
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    int reduceStream = stream.reduce(0, Integer::sum);

    System.out.println(reduceStream);
  }
}

/*
출력
---------reduce Stream 최종 연산---------
15
*/

---

4. collect()

• Stream의 요소를 수집하여 새로운 Collection, List, Set 등으로 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------collect Stream 최종 연산---------");
    FinalOperationStream4 finalOperationStream4 = new FinalOperationStream4();
    finalOperationStream4.FinalOperationStream();
  }
}

class FinalOperationStream4 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    List<String> collectStream = stream.toList();

    System.out.println(collectStream);
  }
}

/*
출력
---------collect Stream 최종 연산---------
[java, spring, springBoot, jpa, queryDSL]
*/

---

5. count()

• Stream의 요소의 개수를 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------count Stream 최종 연산---------");
    FinalOperationStream5 finalOperationStream5 = new FinalOperationStream5();
    finalOperationStream5.FinalOperationStream();
  }
}

class FinalOperationStream5 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    long count = stream.count();

    System.out.println(count);
  }
}

/*
출력
---------count Stream 최종 연산---------
5
*/

---

6. anyMatch()

• 하나 이상의 요소가 조건에 맞는지 검사하여 결과를 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------anyMatch Stream 최종 연산---------");
    FinalOperationStream6 finalOperationStream6 = new FinalOperationStream6();
    finalOperationStream6.FinalOperationStream();
  }
}

class FinalOperationStream6 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    boolean anyMatchStream = stream.anyMatch(str -> str.startsWith("j"));

    System.out.println(anyMatchStream);
  }
}

/*
출력
---------anyMatch Stream 최종 연산---------
true
*/

---

7.allMatch()

• 모든 요소가 조건에 맞는지 검사하여 결과를 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------allMatch Stream 최종 연산---------");
    FinalOperationStream7 finalOperationStream7 = new FinalOperationStream7();
    finalOperationStream7.FinalOperationStream();
  }
}

class FinalOperationStream7 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    boolean allMatchStream = stream.allMatch(str -> str.length() > 5);

    System.out.println(allMatchStream);
  }
}

/*
출력
---------allMatch Stream 최종 연산---------
false
*/

---

8. noneMatch()

• 모든 요소가 조건에 맞지 않는지 검사하여 결과를 반환합니다.

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------noneMatch Stream 최종 연산---------");
    FinalOperationStream8 finalOperationStream8 = new FinalOperationStream8();
    finalOperationStream8.FinalOperationStream();
  }
}

class FinalOperationStream8 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    boolean noneMatchStream = stream.noneMatch(str -> str.startsWith("k"));

    System.out.println(noneMatchStream);
  }
}

/*
출력
---------noneMatch Stream 최종 연산---------
true
*/

---

Stream 활용 예제

스트림에서 요소 찾기

• filter 메서드를 사용하여 조건에 맞는 요소를 찾고 findFirst 메서드를 사용하여 첫 번째 요소를 찾습니다.
• findFirst 메서드는 Optional 인스턴스를 반환하므로, isPresent 메서드로 결과가 존재하는지 확인한 후, get 메서드로 결과를 가져옵니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림에서 요소 찾기---------");
    StreamAPI1 streamAPI1 = new StreamAPI1();
    streamAPI1.streamAPI(list);
  }
}

class StreamAPI1 {
  public void streamAPI(List<String> list) {
    Optional<String> findElement =
        list.stream()
            .filter(s -> s.startsWith("j"))
            .findFirst();

    findElement.ifPresent(System.out::println);
  }
}

/*
출력
---------스트림에서 요소 찾기---------
java
*/

---

스트림에서 요소 수집하기

• collect 메서드를 사용하여 스트림에서 추출한 요소를 컬렉션으로 수집합니다.
• Collectors.toList 메서드를 사용하여 리스트로 수집합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림에서 요소 수집---------");
    StreamAPI2 streamAPI2 = new StreamAPI2();
    streamAPI2.streamAPI(list);
  }
}

class StreamAPI2 {
  public void streamAPI(List<String> list) {
    List<String> collectElement =
        list.stream()
            .filter(s -> s.startsWith("j"))
            .toList();

    System.out.println(collectElement);
  }
}

/*
출력
---------스트림에서 요소 수집---------
[java, jpa]
*/

---

스트림에서 요소 집계하기

• reduce 메서드를 사용하여 스트림에서 요소를 연산할 수 있습니다.
• 예제를 보면 reduce 메서드를 사용하여 numList 스트림에서 모든 요소의 합을 계산한 후, 해당 합을 출력합니다.
• reduce 메서드의 첫 번째 인자는 초기값을 나타내며, 두 번째 인자는 각 요소를 처리하는 람다식입니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림에서 요소 집계---------");
    StreamAPI3 streamAPI3 = new StreamAPI3();
    streamAPI3.streamAPI(numList);
  }
}

class StreamAPI3 {
  public void streamAPI(List<Integer> numList) {
    int aggregationElement = numList.stream().reduce(0, Integer::sum);

    System.out.println(aggregationElement);
  }
}

/*
출력
---------스트림에서 요소 집계---------
15
*/

---

스트림에서 요소 그룹화하기

• groupingBy 메서드를 사용하여 요소를 구룹화할 수 있습니다. 이 메서드는 그룹화 기준이 되는 함수를 인수로 받습니다.
• 예제를 보면 classes 클래스에서 과목을 가져오는 getSubject 메서드를 사용하여 그룹화를 수행합니다. groupingBy 메서드는 Map 인스턴스를 반환하므로, 결과를 출력하려면 println 메서드를 사용합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림에서 요소 그룹화---------");
    StreamAPI4 streamAPI4 = new StreamAPI4();
    streamAPI4.streamAPI();
  }
}

class StreamAPI4 {
  public void streamAPI() {
    List<Classes> classes = Arrays.asList(
        new Classes("Java", 1),
        new Classes("Spring", 2),
        new Classes("SpringBoot", 3),
        new Classes("JPA", 4),
        new Classes("QueryDSL", 5));

    Map<String, List<Classes>> groupElement = classes.stream().collect(Collectors.groupingBy(Classes::getSubject));
    System.out.println(groupElement);
  }
}

class Classes {
  private final String subject;
  private final int period;

  public Classes(String subject, int period) {
    this.subject = subject;
    this.period = period;
  }

  public String getSubject() {
    return subject;
  }

  public int getPeriod() {
    return period;
  }

  @Override
  public String toString() {
    return "Classes [subject=" + subject + ", period=" + period + "]";
  }
}

/*
출력
---------스트림에서 요소 그룹화---------
{Java=[Classes [subject=Java, period=1]], QueryDSL=[Classes [subject=QueryDSL, period=5]], JPA=[Classes [subject=JPA, period=4]], SpringBoot=[Classes [subject=SpringBoot, period=3]], Spring=[Classes [subject=Spring, period=2]]}
*/

 

---

병렬 처리하기

• parallelStream 메서드를 사용하여 스트림을 병렬 처리할 수 있습니다.
• 병렬 처리를 사용하면 대용량 데이터를 빠르게 처리할 수 있습니다.
• 예제를 보면 parallelStream 메서드를 사용하여 스트림을 병렬 처리하고, filter 메서드를 사용하여 j로 시작하는 요소를 추출한 후, count 메서드를 사용하여 해당 요소의 수를 계산합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 병렬 처리---------");
    StreamAPI5 streamAPI5 = new StreamAPI5();
    streamAPI5.streamAPI(list);
  }
}

class StreamAPI5 {
  public void streamAPI(List<String> list) {
    long parallel = list.parallelStream().filter(s -> s.startsWith("j")).count();

    System.out.println(parallel);
  }
}

/*
출력
---------스트림 병렬 처리---------
2
*/

---

Optional 활용하기

• Optional 클래스는 null-safe한 연산을 수행할 때 사용됩니다.
• 예제를 보면 Optional 클래스의 of 메서드를 사용하여 Java 문자열을 감싼 Optional 객체를 생성합니다.
• 그리고 isPresent 메서드를 사용하여 해당 객체가 비어 있는지 여부를 확인합니다.
• 객체가 비어 있지 않으면 get 메서드를 사용하여 해당 값을 가져와 출력합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 Optional 활용---------");
    StreamAPI6 streamAPI6 = new StreamAPI6();
    streamAPI6.streamAPI();
  }
}

class StreamAPI6 {
  public void streamAPI() {
    Optional<String> optional = Optional.of("Java");
    if (optional.isPresent()) {
      String result = optional.get();
      System.out.println(result);
    } else {
      System.out.println("No Value");
    }
  }
}

/*
출력
---------스트림 Optional 활용---------
Java
*/

---

Stream을 배열로 변환하기

• toArray 메서드를 사용하여 스트림을 배열로 변환할 수 있습니다.
• 예제에서는 String 타입을 요소로 갖는 List 객체를 생성한 후, stream 메서드를 사용하여 스트림으로 변환합니다.
• 그리고 toArray 메서드를 사용하여 스트림을 String 타입의 배열로 변환합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 배열 변환---------");
    StreamAPI7 streamAPI7 = new StreamAPI7();
    streamAPI7.streamAPI(list);
  }
}

class StreamAPI7 {
  public void streamAPI(List<String> list) {
    String[] conversionArray = list.toArray(String[]::new);

    System.out.println(Arrays.toString(conversionArray));
  }
}

/*
출력
---------스트림 배열 변환---------
[java, spring, springBoot, jpa, queryDSL]
*/

---

스트림의 모든 요소 처리하기

• forEach 메서드를 사용하여 스트림의 모든 요소를 처리할 수 있습니다.
• 예제를 보면 Integer 타입을 요소로 갖는 List 객체를 생성한 후, forEach 메서드를 사용하여 해당 요소를 출력합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 모든 요소 처리---------");
    StreamAPI8 streamAPI8 = new StreamAPI8();
    streamAPI8.streamAPI(list);
  }
}

class StreamAPI8 {
  public void streamAPI(List<String> list) {
    list.forEach(System.out::println);
  }
}

/*
출력
---------스트림 모든 요소 처리---------
java
spring
springBoot
jpa
queryDSL
*/

---

스트림에서 값 추출하기

• 스트림에서 값을 추출할 때는 mapToInt, mapToLong, mapToDouble과 같은 메서드를 사용하여 원하는 형태로 변환한 후 추출할 수 있습니다.
• 예제를 보면 mapToInt 메서드를 사용하여 Integer 타입을 int 타입으로 변환 후 sum 메서드를 사용하여 모든 요소의 합을 구합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 값 추출---------");
    StreamAPI9 streamAPI9 = new StreamAPI9();
    streamAPI9.streamAPI(numList);
  }
}

class StreamAPI9 {
  public void streamAPI(List<Integer> numList) {
    int valueExtraction =
        numList.stream()
            .mapToInt(Integer::intValue)
            .sum();

    System.out.println(valueExtraction);
  }
}

/*
출력
---------스트림 값 추출---------
15
*/

---

스트림에서 중복 요소 제거하기

• distinct 메서드를 사용하여 스트림에서 중복 요소를 제거할 수 있습니다.
• 예제를 보면 distinct 메서드를 사용하여 중복된 1 요소를 제거한 후, toList 메서드를 사용하여 해당 요소를 제거한 새로운 List 객체를 출력합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 중복 제거---------");
    StreamAPI10 streamAPI10 = new StreamAPI10();
    streamAPI10.streamAPI();
  }
}

class StreamAPI10 {
  public void streamAPI() {
    List<Integer> arr = Arrays.asList(1, 2, 3, 4, 5, 1);
    List<Integer> deduplication =
        arr.stream()
            .distinct()
            .toList();

    System.out.println(deduplication);
  }
}

/*
출력
---------스트림 중복 제거---------
[1, 2, 3, 4, 5]
*/

---

스트림에서 요소 분할하기

• partitioningBy 메서드를 사용하여 스트림에서 요소를 분할할 수 있습니다.
• 예제를 보면 splitElements라는 Map 객체에 2로 나누어 떨어지는 요소와 아닌 요소를 분할한 결과를 저장합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 요소 분할---------");
    StreamAPI11 streamAPI11 = new StreamAPI11();
    streamAPI11.streamAPI(numList);
  }
}

class StreamAPI11 {
  public void streamAPI(List<Integer> numList) {
    Map<Boolean, List<Integer>> splitElements =
        numList.stream()
            .collect(Collectors.partitioningBy(i -> i % 2 == 0));

    System.out.println(splitElements);
  }
}

/*
출력
---------스트림 요소 분할---------
{false=[1, 3, 5], true=[2, 4]}
*/

---

스트림에서 요소 정렬하기

• sorted 메서드를 사용하여 스트림에서 요소를 정렬할 수 있습니다.
• 예제를 보면 sorted 메서드를 사용하여 해당 스트림을 오름차순으로 정렬한 후, toList 메서드를 사용하여 해당 요소를 포함하는 새로운 List 객체를 생성합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 요소 정렬---------");
    StreamAPI12 streamAPI12 = new StreamAPI12();
    streamAPI12.streamAPI();
  }
}

class StreamAPI12 {
  public void streamAPI() {
    List<Integer> list = Arrays.asList(5, 1, 3, 2, 4);
    List<Integer> sortElement =
        list.stream()
            .sorted()
            .toList();

    System.out.println(sortElement);
  }
}

/*
출력
---------스트림 요소 정렬---------
[1, 2, 3, 4, 5]
*/

---

스트림에서 요소 제한하기

• limit 메서드를 사용하여 스트림에서 요소를 제한할 수 있습니다.
• 예제를 보면 limit 메서드를 사용하여 해당 스트림에서 최대 3개의 요소만 추출한 후, toList 메서드를 사용하여 새로운 List 객체를 생성합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 요소 제한---------");
    StreamAPI13 streamAPI13 = new StreamAPI13();
    streamAPI13.streamAPI(numList);
  }
}

class StreamAPI13 {
  public void streamAPI(List<Integer> numList) {
    List<Integer> limitElement =
        numList.stream()
            .limit(3)
            .toList();

    System.out.println(limitElement);
  }
}

/*
출력
---------스트림 요소 제한---------
[1, 2, 3]
*/

---

스트림에서 요서 건너뛰기

• skip 메서드를 사용하여 스트림에서 요소를 건너뛸 수 있습니다.
• 예제를 보면 skip 메서드를 사용하여 해당 스트림에서 처음 3개의 요소를 건너 뛴 후, 나머지 요소를 추출한 후, toList 메서드를 사용하여 해당 요소를 포함하는 새로운 List 객체를 생성합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 요소 건너뛰기---------");
    StreamAPI14 streamAPI14 = new StreamAPI14();
    streamAPI14.streamAPI(numList);
  }
}

class StreamAPI14 {
  public void streamAPI(List<Integer> numList) {
    List<Integer> skipElement =
        numList.stream()
            .skip(3)
            .toList();

    System.out.println(skipElement);
  }
}

/*
출력
---------스트림 요소 건너뛰기---------
[4, 5]
*/

---

스트림에서 요소 매핑하기

• flatMap 메서드를 사용하여 스트림에서 요소를 매핑할 수 있습니다.
• 예제를 보면 flatMap 메서드를 사용하여 list 리스트에서 각 문자열을 배열로 분할하고, 각 문자를 개별 요소로 만든 후 해당 요소를 포함하는 새로운 스트림을 생성합니다.
• 이후, distinct 메서드를 사용하여 중복 요소를 제거한 후, toList 메서드를 사용하여 새로운 List 객체를 생성합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 요소 매핑---------");
    StreamAPI15 streamAPI15 = new StreamAPI15();
    streamAPI15.streamAPI(list);
  }
}

class StreamAPI15 {
  public void streamAPI(List<String> list) {
    List<String> mappingElement =
        list.stream()
            .flatMap(s -> Arrays.stream(s.split("")))
            .distinct()
            .toList();

    System.out.println(mappingElement);
  }
}

/*
출력
---------스트림 요소 매핑---------
[j, a, v, s, p, r, i, n, g, B, o, t, q, u, e, y, D, S, L]
*/

---

스트림에서 요소 집계하기

• summaryStatistics 메서드를 사용하여 스트림에서 요소를 집계할 수 있습니다.
• 예제를 보면 summaryStatistics 메서드를 사용하여 numList 스트림에서 요소의 합, 평균, 최대값, 최소값, 개수 등을 계산한 후, 해당 값을 포함하는 새로운 IntSummaryStatistics 객체를 생성합니다.
• 이후, 해당 객체를 출력합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 요소 집계---------");
    StreamAPI16 streamAPI16 = new StreamAPI16();
    streamAPI16.streamAPI(numList);
  }
}

class StreamAPI16 {
  public void streamAPI(List<Integer> numList) {
    IntSummaryStatistics aggregationElement =
        numList.stream()
            .mapToInt((x) -> x)
            .summaryStatistics();

    System.out.println(aggregationElement);
  }
}

/*
출력
---------스트림 요소 집계---------
IntSummaryStatistics{count=5, sum=15, min=1, average=3.000000, max=5}
*/

---

스트림에서 요소 카운트하기

• count 메서드를 사용하여 스트림에서 요소를 카운트할 수 있습니다.
• 예제를 보면 count 메서드를 사용하여 list 스트림에서 요소의 개수를 계산한 후, 해당 개수를 출력합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 요소 카운트---------");
    StreamAPI17 streamAPI17 = new StreamAPI17();
    streamAPI17.streamAPI(numList);
  }
}

class StreamAPI17 {
  public void streamAPI(List<Integer> numList) {
    long countStream =
        numList.stream()
            .count();

    System.out.println(countStream);
  }
}

/*
출력
---------스트림 요소 카운트---------
5
*/

---

스트림에서 요소 변환하기

• map 메서드를 사용하여 스트림에서 요소를 변환할 수 있습니다.
• 예제를 보면 map 메서드를 사용하여 list 스트림에서 모든 문자열을 대문자로 변환한 후, 해당 요소를 포함하는 새로운 List 객체를 생성합니다.

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림 요소 변환---------");
    StreamAPI18 streamAPI18 = new StreamAPI18();
    streamAPI18.streamAPI(list);
  }
}

class StreamAPI18 {
  public void streamAPI(List<String> list) {
    List<String> conversionElement =
        list.stream()
            .map(String::toUpperCase)
            .toList();

    System.out.println(conversionElement);
  }
}

/*
출력
---------스트림 요소 변환---------
[JAVA, SPRING, SPRINGBOOT, JPA, QUERYDSL]
*/

---

전체 코드

StreamAPI 작성법

package streamAPI;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;

public class StreamAPI {
  public static void main(String[] args) {
    System.out.println("\n---------Collection Stream 생성---------");
    CreateStream1 createStream1 = new CreateStream1();
    createStream1.createStream();

    System.out.println("\n---------Array Stream 생성---------");
    CreateStream2 createStream2 = new CreateStream2();
    createStream2.createStream();

    System.out.println("\n---------Stream.of Stream 생성---------");
    CreateStream3 createStream3 = new CreateStream3();
    createStream3.createStream();

    System.out.println("\n---------filter Stream 중간 연산---------");
    IntermediateOperationStream1 intermediateOperationStream1 = new IntermediateOperationStream1();
    intermediateOperationStream1.IntermediateOperationStream();

    System.out.println("\n---------map Stream 중간 연산---------");
    IntermediateOperationStream2 intermediateOperationStream2 = new IntermediateOperationStream2();
    intermediateOperationStream2.IntermediateOperationStream();

    System.out.println("\n---------flatMap Stream 중간 연산---------");
    IntermediateOperationStream3 intermediateOperationStream3 = new IntermediateOperationStream3();
    intermediateOperationStream3.IntermediateOperationStream();

    System.out.println("\n---------sorted Stream 중간 연산---------");
    IntermediateOperationStream4 intermediateOperationStream4 = new IntermediateOperationStream4();
    intermediateOperationStream4.IntermediateOperationStream();

    System.out.println("\n---------distinct Stream 중간 연산---------");
    IntermediateOperationStream5 intermediateOperationStream5 = new IntermediateOperationStream5();
    intermediateOperationStream5.IntermediateOperationStream();

    System.out.println("\n---------limit Stream 중간 연산---------");
    IntermediateOperationStream6 intermediateOperationStream6 = new IntermediateOperationStream6();
    intermediateOperationStream6.IntermediateOperationStream();

    System.out.println("\n---------skip Stream 중간 연산---------");
    IntermediateOperationStream7 intermediateOperationStream7 = new IntermediateOperationStream7();
    intermediateOperationStream7.IntermediateOperationStream();

    System.out.println("\n---------forEach Stream 최종 연산---------");
    FinalOperationStream1 finalOperationStream1 = new FinalOperationStream1();
    finalOperationStream1.FinalOperationStream();

    System.out.println("\n---------toArray Stream 최종 연산---------");
    FinalOperationStream2 finalOperationStream2 = new FinalOperationStream2();
    finalOperationStream2.FinalOperationStream();

    System.out.println("\n---------reduce Stream 최종 연산---------");
    FinalOperationStream3 finalOperationStream3 = new FinalOperationStream3();
    finalOperationStream3.FinalOperationStream();

    System.out.println("\n---------collect Stream 최종 연산---------");
    FinalOperationStream4 finalOperationStream4 = new FinalOperationStream4();
    finalOperationStream4.FinalOperationStream();

    System.out.println("\n---------count Stream 최종 연산---------");
    FinalOperationStream5 finalOperationStream5 = new FinalOperationStream5();
    finalOperationStream5.FinalOperationStream();

    System.out.println("\n---------anyMatch Stream 최종 연산---------");
    FinalOperationStream6 finalOperationStream6 = new FinalOperationStream6();
    finalOperationStream6.FinalOperationStream();

    System.out.println("\n---------allMatch Stream 최종 연산---------");
    FinalOperationStream7 finalOperationStream7 = new FinalOperationStream7();
    finalOperationStream7.FinalOperationStream();

    System.out.println("\n---------noneMatch Stream 최종 연산---------");
    FinalOperationStream8 finalOperationStream8 = new FinalOperationStream8();
    finalOperationStream8.FinalOperationStream();
  }
}

class CreateStream1 {
  public void createStream() {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> stream = list.stream();

    stream.forEach(System.out::println);
  }
}

class CreateStream2 {
  public void createStream() {
    String[] arr = {"java", "spring", "springBoot", "jpa", "queryDSL"};
    Stream<String> stream = Arrays.stream(arr);

    stream.forEach(System.out::println);
  }
}

class CreateStream3 {
  public void createStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");

    stream.forEach(System.out::println);
  }
}

class IntermediateOperationStream1 {
  public void IntermediateOperationStream() {
    System.out.println("filter 조건 : 원소 중 길이 5 이상인 원소 출력");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> filterStream = stream.filter(str -> str.length() > 5);

    filterStream.forEach(System.out::println);
  }
}

class IntermediateOperationStream2 {
  public void IntermediateOperationStream() {
    System.out.println("map 조건 : 각 원소 길이만 출력");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<Integer> mapStream = stream.map(String::length);

    mapStream.forEach(System.out::println);
  }
}

class IntermediateOperationStream3 {
  public void IntermediateOperationStream() {
    System.out.println("flatMap 조건 : 두 Stream을 새롭게 생성하고 하나의 Stream으로 병합");
    Stream<List<Integer>> stream = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4));
    Stream<Integer> flatMapStream = stream.flatMap(Collection::stream);

    flatMapStream.forEach(System.out::println);
  }
}

class IntermediateOperationStream4 {
  public void IntermediateOperationStream() {
    System.out.println("sort 조건 : 기본(오름차순) 정렬");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> sortStream = stream.sorted();

    sortStream.forEach(System.out::println);
  }
}

class IntermediateOperationStream5 {
  public void IntermediateOperationStream() {
    System.out.println("distinct 조건 : 중복 요소 제거");
    Stream<String> stream = Stream.of("java", "java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> distinctStream = stream.distinct();

    distinctStream.forEach(System.out::println);
  }
}

class IntermediateOperationStream6 {
  public void IntermediateOperationStream() {
    System.out.println("limit 조건 : 입력한 파라미터 만큼만 출력");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> limitStream = stream.limit(3);

    limitStream.forEach(System.out::println);
  }
}

class IntermediateOperationStream7 {
  public void IntermediateOperationStream() {
    System.out.println("입력한 파리미터 만큼 건너뛰고 출력");
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    Stream<String> skip = stream.skip(3);

    skip.forEach(System.out::println);
  }
}

class FinalOperationStream1 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");

    stream.forEach(System.out::println);
  }
}

class FinalOperationStream2 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");

    String[] toArrayStream = stream.toArray(String[]::new);
    System.out.println(Arrays.toString(toArrayStream));
  }
}

class FinalOperationStream3 {
  public void FinalOperationStream() {
    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    int reduceStream = stream.reduce(0, Integer::sum);

    System.out.println(reduceStream);
  }
}

class FinalOperationStream4 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    List<String> collectStream = stream.toList();

    System.out.println(collectStream);
  }
}

class FinalOperationStream5 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    long count = stream.count();

    System.out.println(count);
  }
}

class FinalOperationStream6 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    boolean anyMatchStream = stream.anyMatch(str -> str.startsWith("j"));

    System.out.println(anyMatchStream);
  }
}

class FinalOperationStream7 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    boolean allMatchStream = stream.allMatch(str -> str.length() > 5);

    System.out.println(allMatchStream);
  }
}

class FinalOperationStream8 {
  public void FinalOperationStream() {
    Stream<String> stream = Stream.of("java", "spring", "springBoot", "jpa", "queryDSL");
    boolean noneMatchStream = stream.noneMatch(str -> str.startsWith("k"));

    System.out.println(noneMatchStream);
  }
}

/*
출력
---------Collection Stream 생성---------
java
spring
springBoot
jpa
queryDSL

---------Array Stream 생성---------
java
spring
springBoot
jpa
queryDSL

---------Stream.of Stream 생성---------
java
spring
springBoot
jpa
queryDSL

---------filter Stream 중간 연산---------
filter 조건 : 원소 중 길이 5 이상인 원소 출력
spring
springBoot
queryDSL

---------map Stream 중간 연산---------
map 조건 : 각 원소 길이만 출력
4
6
10
3
8

---------flatMap Stream 중간 연산---------
flatMap 조건 : 두 Stream을 새롭게 생성하고 하나의 Stream으로 병합
1
2
3
4

---------sorted Stream 중간 연산---------
sort 조건 : 기본(오름차순) 정렬
java
jpa
queryDSL
spring
springBoot

---------distinct Stream 중간 연산---------
distinct 조건 : 중복 요소 제거
java
spring
springBoot
jpa
queryDSL

---------limit Stream 중간 연산---------
limit 조건 : 입력한 파라미터 만큼만 출력
java
spring
springBoot

---------skip Stream 중간 연산---------
입력한 파리미터 만큼 건너뛰고 출력
jpa
queryDSL

---------forEach Stream 최종 연산---------
java
spring
springBoot
jpa
queryDSL

---------toArray Stream 최종 연산---------
[java, spring, springBoot, jpa, queryDSL]

---------reduce Stream 최종 연산---------
15

---------collect Stream 최종 연산---------
[java, spring, springBoot, jpa, queryDSL]

---------count Stream 최종 연산---------
5

---------anyMatch Stream 최종 연산---------
true

---------allMatch Stream 최종 연산---------
false

---------noneMatch Stream 최종 연산---------
true
*/

---

StreamAPI 활용

package streamAPI;

import java.util.*;
import java.util.stream.Collectors;

public class StreamAPIUtilization {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("java", "spring", "springBoot", "jpa", "queryDSL");
    List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);

    System.out.println("\n---------스트림에서 요소 찾기---------");
    StreamAPI1 streamAPI1 = new StreamAPI1();
    streamAPI1.streamAPI(list);

    System.out.println("\n---------스트림에서 요소 수집---------");
    StreamAPI2 streamAPI2 = new StreamAPI2();
    streamAPI2.streamAPI(list);

    System.out.println("\n---------스트림에서 요소 집계---------");
    StreamAPI3 streamAPI3 = new StreamAPI3();
    streamAPI3.streamAPI(numList);

    System.out.println("\n---------스트림에서 요소 그룹화---------");
    StreamAPI4 streamAPI4 = new StreamAPI4();
    streamAPI4.streamAPI();

    System.out.println("\n---------스트림 병렬 처리---------");
    StreamAPI5 streamAPI5 = new StreamAPI5();
    streamAPI5.streamAPI(list);

    System.out.println("\n---------스트림 Optional 활용---------");
    StreamAPI6 streamAPI6 = new StreamAPI6();
    streamAPI6.streamAPI();

    System.out.println("\n---------스트림 배열 변환---------");
    StreamAPI7 streamAPI7 = new StreamAPI7();
    streamAPI7.streamAPI(list);

    System.out.println("\n---------스트림 모든 요소 처리---------");
    StreamAPI8 streamAPI8 = new StreamAPI8();
    streamAPI8.streamAPI(list);

    System.out.println("\n---------스트림 값 추출---------");
    StreamAPI9 streamAPI9 = new StreamAPI9();
    streamAPI9.streamAPI(numList);

    System.out.println("\n---------스트림 중복 제거---------");
    StreamAPI10 streamAPI10 = new StreamAPI10();
    streamAPI10.streamAPI();

    System.out.println("\n---------스트림 요소 분할---------");
    StreamAPI11 streamAPI11 = new StreamAPI11();
    streamAPI11.streamAPI(numList);

    System.out.println("\n---------스트림 요소 정렬---------");
    StreamAPI12 streamAPI12 = new StreamAPI12();
    streamAPI12.streamAPI();

    System.out.println("\n---------스트림 요소 제한---------");
    StreamAPI13 streamAPI13 = new StreamAPI13();
    streamAPI13.streamAPI(numList);

    System.out.println("\n---------스트림 요소 건너뛰기---------");
    StreamAPI14 streamAPI14 = new StreamAPI14();
    streamAPI14.streamAPI(numList);

    System.out.println("\n---------스트림 요소 매핑---------");
    StreamAPI15 streamAPI15 = new StreamAPI15();
    streamAPI15.streamAPI(list);

    System.out.println("\n---------스트림 요소 집계---------");
    StreamAPI16 streamAPI16 = new StreamAPI16();
    streamAPI16.streamAPI(numList);

    System.out.println("\n---------스트림 요소 카운트---------");
    StreamAPI17 streamAPI17 = new StreamAPI17();
    streamAPI17.streamAPI(numList);

    System.out.println("\n---------스트림 요소 변환---------");
    StreamAPI18 streamAPI18 = new StreamAPI18();
    streamAPI18.streamAPI(list);
  }
}

class StreamAPI1 {
  public void streamAPI(List<String> list) {
    Optional<String> findElement =
        list.stream()
            .filter(s -> s.startsWith("j"))
            .findFirst();

    findElement.ifPresent(System.out::println);
  }
}

class StreamAPI2 {
  public void streamAPI(List<String> list) {
    List<String> collectElement =
        list.stream()
            .filter(s -> s.startsWith("j"))
            .toList();

    System.out.println(collectElement);
  }
}

class StreamAPI3 {
  public void streamAPI(List<Integer> numList) {
    int aggregationElement = numList.stream().reduce(0, Integer::sum);

    System.out.println(aggregationElement);
  }
}

class StreamAPI4 {
  public void streamAPI() {
    List<Classes> classes = Arrays.asList(
        new Classes("Java", 1),
        new Classes("Spring", 2),
        new Classes("SpringBoot", 3),
        new Classes("JPA", 4),
        new Classes("QueryDSL", 5));

    Map<String, List<Classes>> groupElement = classes.stream().collect(Collectors.groupingBy(Classes::getSubject));
    System.out.println(groupElement);
  }
}

class Classes {
  private final String subject;
  private final int period;

  public Classes(String subject, int period) {
    this.subject = subject;
    this.period = period;
  }

  public String getSubject() {
    return subject;
  }

  public int getPeriod() {
    return period;
  }

  @Override
  public String toString() {
    return "Classes [subject=" + subject + ", period=" + period + "]";
  }
}

class StreamAPI5 {
  public void streamAPI(List<String> list) {
    long parallel = list.parallelStream().filter(s -> s.startsWith("j")).count();

    System.out.println(parallel);
  }
}

class StreamAPI6 {
  public void streamAPI() {
    Optional<String> optional = Optional.of("Java");
    if (optional.isPresent()) {
      String result = optional.get();
      System.out.println(result);
    } else {
      System.out.println("No Value");
    }
  }
}

class StreamAPI7 {
  public void streamAPI(List<String> list) {
    String[] conversionArray = list.toArray(String[]::new);

    System.out.println(Arrays.toString(conversionArray));
  }
}

class StreamAPI8 {
  public void streamAPI(List<String> list) {
    list.forEach(System.out::println);
  }
}

class StreamAPI9 {
  public void streamAPI(List<Integer> numList) {
    int valueExtraction =
        numList.stream()
            .mapToInt(Integer::intValue)
            .sum();

    System.out.println(valueExtraction);
  }
}

class StreamAPI10 {
  public void streamAPI() {
    List<Integer> arr = Arrays.asList(1, 2, 3, 4, 5, 1);
    List<Integer> deduplication =
        arr.stream()
            .distinct()
            .toList();

    System.out.println(deduplication);
  }
}

class StreamAPI11 {
  public void streamAPI(List<Integer> numList) {
    Map<Boolean, List<Integer>> splitElements =
        numList.stream()
            .collect(Collectors.partitioningBy(i -> i % 2 == 0));

    System.out.println(splitElements);
  }
}

class StreamAPI12 {
  public void streamAPI() {
    List<Integer> list = Arrays.asList(5, 1, 3, 2, 4);
    List<Integer> sortElement =
        list.stream()
            .sorted()
            .toList();

    System.out.println(sortElement);
  }
}

class StreamAPI13 {
  public void streamAPI(List<Integer> numList) {
    List<Integer> limitElement =
        numList.stream()
            .limit(3)
            .toList();

    System.out.println(limitElement);
  }
}

class StreamAPI14 {
  public void streamAPI(List<Integer> numList) {
    List<Integer> skipElement =
        numList.stream()
            .skip(3)
            .toList();

    System.out.println(skipElement);
  }
}

class StreamAPI15 {
  public void streamAPI(List<String> list) {
    List<String> mappingElement =
        list.stream()
            .flatMap(s -> Arrays.stream(s.split("")))
            .distinct()
            .toList();

    System.out.println(mappingElement);
  }
}

class StreamAPI16 {
  public void streamAPI(List<Integer> numList) {
    IntSummaryStatistics aggregationElement =
        numList.stream()
            .mapToInt((x) -> x)
            .summaryStatistics();

    System.out.println(aggregationElement);
  }
}

class StreamAPI17 {
  public void streamAPI(List<Integer> numList) {
    long countStream =
        numList.stream()
            .count();

    System.out.println(countStream);
  }
}

class StreamAPI18 {
  public void streamAPI(List<String> list) {
    List<String> conversionElement =
        list.stream()
            .map(String::toUpperCase)
            .toList();

    System.out.println(conversionElement);
  }
}

/*
출력
---------스트림에서 요소 찾기---------
java

---------스트림에서 요소 수집---------
[java, jpa]

---------스트림에서 요소 집계---------
15

---------스트림에서 요소 그룹화---------
{Java=[Classes [subject=Java, period=1]], QueryDSL=[Classes [subject=QueryDSL, period=5]], JPA=[Classes [subject=JPA, period=4]], SpringBoot=[Classes [subject=SpringBoot, period=3]], Spring=[Classes [subject=Spring, period=2]]}

---------스트림 병렬 처리---------
2

---------스트림 Optional 활용---------
Java

---------스트림 배열 변환---------
[java, spring, springBoot, jpa, queryDSL]

---------스트림 모든 요소 처리---------
java
spring
springBoot
jpa
queryDSL

---------스트림 값 추출---------
15

---------스트림 중복 제거---------
[1, 2, 3, 4, 5]

---------스트림 요소 분할---------
{false=[1, 3, 5], true=[2, 4]}

---------스트림 요소 정렬---------
[1, 2, 3, 4, 5]

---------스트림 요소 제한---------
[1, 2, 3]

---------스트림 요소 건너뛰기---------
[4, 5]

---------스트림 요소 매핑---------
[j, a, v, s, p, r, i, n, g, B, o, t, q, u, e, y, D, S, L]

---------스트림 요소 집계---------
IntSummaryStatistics{count=5, sum=15, min=1, average=3.000000, max=5}

---------스트림 요소 카운트---------
5

---------스트림 요소 변환---------
[JAVA, SPRING, SPRINGBOOT, JPA, QUERYDSL]
*/