[TIL] 스트림

💪🏻 스트림 Stream

 - 데이터의 흐름

 - 배열과 컬렉션을 함수형으로 처리

 - 배열 또는 컬렉션 인스턴스에 함수 여러 개를 조합해서 원하는 결과를 필터링하고 가공된 결과를 얻을 수 있음

 - 코드의 양을 줄이고 간결하게 표현할 수 있음 = 저장공간 필요 없음

 - 배열, 컬렉션의 저장 요소를 하나씩 참조해서 람다식으로 처리할 수 있도록 해주는 반복자

 - 다양한 데이터 소스를 다루는 풍부한 메서드 제공

---

📍 스트림 특징

1️⃣  선언형

  - 선언형 프로그래밍 ? 어떻게 보다는 무엇을 수행하는지 관심을 두는 프로그래밍

  - 선언형 방식으로 작성하면 내부 동작 원리를 몰라도 코드가 무슨 일 하는지 이해 가능

2️⃣  람다식으로 요소 처리 코드를 제공

- 스트림이 제공하는 대부분의 요소 처리 메소드는 함수적 인터페이스 매개타입을 가짐

- 매개값으로 람다식 또는 메소드 참조를 대입할 수 있음

stream.forEach( x -> {
    String id = x.getId();
    int pw = x.getPw();
    System.out.println("id는 " + id + "pw는 " + pw);
});

3️⃣  내부 반복자를 사용하여 병렬 처리가 쉬움

  💡 외부 반복자 ? 개발자가 코드로 직접 컬렉션의 요소를 반복해서 가져오는 패턴

    → for문, while 문 등

 

  💡 내부 반복자 ? 컬렉션 내부에서 요소들을 반복시키고 개발자는 처리해야 할 코드만 제공하는 패턴

    → 개발자는 요소 처리 코드에만 집중 (컬렉션이 요소 반복 담당)

    → 요소들을 분배시켜 병렬 처리 작업 가능

 

  💡 병렬 처리 ? 한 가지 작업을 서브 작업으로 나누어 분리된 스레드에서 병렬적으로 처리

4️⃣  중간 연산과 최종 연산 가능

  - 중간 연산 : 매핑, 그루핑, 필터링, 정렬

  - 최종 연산 : 반복, 카운팅, 평균, 총합, 최대/최소값

double sum = list.stream()
                .mapToInt(Age:: getAge)
                .sum()
                .getAsDouble();
    System.out.println("합계: " + sum);

---

📍 파이프라인 구성 (.)

  - 파이프라인 ? 여러 개의 스트림이 연결되어 있는 구조

  - 파이프라인에서 최종 연산을 제외하고는 모두 중간 연산 스트림 !

  - 최종연산이 실행되어야 중간 스트림에서 연산 시작

---

👏🏻 스트림 생성 및 연산 과정

📍 스트림 생성 

Stream<String> Stream명 = list.stream();  (1) 리스트 스트림
Stream<String> Stream명 = Arrys.stream(~); (2) 배열 스트림
Stream<String> Stream명 = Stream.of(~);    (3) 가변 배열 스트림

  - stream( )을 사용하면 해당 컬렉션 객체를 Stream으로 반환

  - 컬렉션 인터페이스에는 stream()이 이미 정의되어있음

1️⃣ 컬렉션 스트림

package Stream;
import java.util.*;
import java.util.stream.Stream;

public class liststream {
    public static void main(String[] args) {
        List<String> ls = Arrays.asList("One", "Two", "Three");
        Stream<String> lsStream = ls.stream();
        lsStream.forEach(System.out::println);
    }
}

 - 컬렉션 타입(Collection, List, Set)의 경우 stream 메소드를 이용해서 만들 수 있음

2️⃣ 배열 스트림

package Stream;
import java.util.*;
import java.util.stream.Stream;

public class ArrayStream {
    public static void main(String[] args) {
        String[] arr = new String[]{"하나","둘","셋"};

        Stream<String> arrStream = Arrays.stream(arr);
        arrStream.forEach(x -> System.out.print(x + " "));

        System.out.println();

        Stream<String> arrSteam2 = Arrays.stream(arr,1,2);
        arrSteam2.forEach(y -> System.out.print(y + " "));

        System.out.println();
        
        Stream<Double> st = Stream.of(4.3,2.4,2.9);
        st.forEach(System.out::println);
    }
}

//결과
하나 둘 셋 
둘 
4.3
2.4
2.9

  💡 Array.stream

     - Array.stream(arr)을 사용할 수 도 있고 부분 문자 출력을 원하면 Arrays.strema(arr,1,2)처럼 사용하면 됨

 💡 forEach( )

     - 해당 스트림의 요소를 하나씩 소모해가며 순차적으로 요소에 접근하는 메소드

  💡 stream.of

     - Stream 클래스의 of 메소드는 가변 매개변수를 전달받아 스트림을 생성할 수 있음

---

▪️ 컬렉션으로부터 스트림 생성

List<Integer> 참조변수 = Arrays.asList(1,2,3,4,5);
Stream<Integer> st = ls.stream();

▪️ 배열로부터 스트림 생성

Stream<String> stream = Arrays.stream(T[])
Stream<String> stream = Arrays.stream(int[])
Stream<String> stream = Arrays.stream(long[])
Stream<String> stream = Arrays.stream(double[])

Stream<String> stream = Stream.of(T[])
Stream<String> stream = IntStream.of(int[])
Stream<String> stream = LongStream.of(long[])
Stream<String> stream = DoubleStream.of(double[])

▪️ 특정 범위의 정수를 요소로 갖는 스트림 생성

IntStream intstream = IntStream.range(1,5)
IntStream intstream = IntStream.rangeClosed(1,5)

LongStream longstream = LongStream.range(1,5)
LongStream longstream = LongStream.rangeClosed(1,5)

 

---

👋🏻 중간 연산

 - 중간연산은 연산 결과를 스트림으로 반환하기 때문에 연속해서 여러 번 수행할 수 있음

📍 필터링

   🔎 distinct( )

    : 스트림의 요소들에 중복된 데이터 제거

   🔎 filter( )

    : 조건에 맞는 데이터만 정제하여 작은 컬렉션을 만듦

List<String> sick = Arrays.asList("두통","근육통","고열","복통","근육통");
sick.stream()
            .distinct()
            .forEach(n -> System.out.println(n));

sick.stream()
            .filter( x -> x.startsWith("두"))
            .forEach(x-> System.out.println(x));

    💡 startsWith(체크할 문자열)

     - 체크할 문자열로 시작하는지 확인

     - a.startsWith("JAVA")일 때, 문자열이 JAVA로 시작한다면 True !

    💡 endsWith(체크할 문자열)

     - 체크할 문자열로 끝나는지 확인

     - b.endsWith("Programming")일 때 끝 문자열과 일치한다면 True !

---

📍 매핑

   🔎 map( )

    : 새로운 스트림을 형성하는 것으로 기존의 스트림 요소들을 대체하는 요소

     - 일반적인 Stream 객체를 원시 Stream으로 바꾸거나 그 반대 작업이 필요한 경우에 사용

     - 스트림의 스트림을 반환 !!!! return : Stream <Stream>

    → map 이외에도 mapToInt(), mapToLong, mapToDouble 

List<String> coffee = Arrays.asList("americano", "caffe latte" ,"cappuccino");
coffee.stream()
             .map(x -> x.toLowerCase())
             .forEach(x->System.out.println(x));

    💡 flatMap( )

     - 요소를 대체하는 복수 개의 요소들로 구성된 새로운 스트림 리턴

     - 초기 생성된 스트림 형태가 배열인 경우, 모든 원소를 단일 스트림으로 반환 할 수 있음

     - 스트림 반환 !!!! return : Stream

---

📍 정렬

   🔎 sorted( )

    : 스트림의 요소들을 정렬

     - 오름차순 : sorted( ) 

     - 내림차순 : sorted(Comparator.reverseOrder( ))

List<String> person = Arrays.asList("Hand","Foot","Body","Face");

person.stream()
            .sorted(Comparator.reverseOrder())
            .forEach(x->System.out.println(x));

 

---

📍 연산 결과 확인

   🔎 peek( )

    : 중간 연산 메서드로, 요소를 하나씩 돌면서 출력

    - 하나의 스트림에 여러 번 사용할 수 있음

    - 주로 연산 중간에 결과를 확인하여 디버깅하고자 할 때 사용

      * 디버깅 ? 오류나 버그를 찾아내고 수정하는 작업

   🔎 forEach( )

    : 최종 연산 메서드로, 요소를 하나씩 돌면서 출력

    - 한 번만 호출가능 (재호출하려면 새로운 스트림 생성해야 함)

 

---

👋🏻  최종 연산

 - 연산 결과를 한 번만 실행 가능

📍 연산 결과 확인

   🔎 forEach( )

    : 파이프라인 마지막에서 요소를 하나씩 연산

      - 리턴 값이 없는 이메일 발송, 스케줄링 작업에서도 사용됨

---

📍 매칭 

   🔎 match( )

    : 스트림의 요소들이 특정한 조건을 충족하는지 검사하고 싶은 경우 사용

     - 함수형 인터페이스를 받아 해당 조건을 만족하는지 검사하고 true/false로 반환

      1️⃣ allMatch( ) 

       : 모든 요소들이 매개값으로 주어진 조건에 만족하는지 조사

      2️⃣ anyMatch( ) 

       : 최소한 한 개의 요소가 매개값으로 주어진 조건을 만족하는지 조사

      3️⃣ noneMatch( ) 

       : 모든 요소들이 매개값으로 주어진 조건을 만족하지 않는지 조사

public class matchTest {
    public static void main(String[] args) {
        int[] num = { 1, 3, 5};
        boolean result = Arrays.stream(num).allMatch(x->x%2==1);
        System.out.println("홀수 인가요 ? " + result);

        result = Arrays.stream(num).anyMatch(x->x%3==0);
        System.out.println("3의 배수가 있나여? "+result);

        result = Arrays.stream(num).noneMatch(x-> x%3==0);
        System.out.println("3의 배수가 없나요? " + result);
    }
        }

---

📍 기본 집계

   🔎 sum( ), count( ), average( ), max( ), min( )

    : 요소들을 합계, 카운팅, 평균, 최대, 최소 값 등으로 연산하여 하나의 값으로 산출

int[] arr = { 1, 2, 3, 4, 5};

long count = Arrays.stream(arr).count();

long sum = Arrays.stream(arr).sum();

double avg = Arrays.stream(arr).average().getAsDouble();

int max = Arrays.stream(arr).max().getAsInt();

 

   🔎 reduce

    : 누적하여 하나로 응축하는 방식으로 다양한 집계 결과물을 만들 수 있음

.reduce(0, (a,b) -> a + b )
(1) Accumulator : 각 요소를 계산한 중간 결과를 생성하기 위해 사용
(2) Identity : 계산을 수행하기 윟나 초기값
(3) Combiner : 병렬 스트림에서 나누어 계산된 결과를 하나로 합치기 위한 로직

   🔎 Collect( )

    : 스트림의 요소들을 다른 종류의 결과로 새롭게 수집하고 싶을 경우 사용

     - Collector 매개 값은 어떤 요소를 어떤 컬렉션에 수집할 것인지를 나타냄 

.collect(Collectors.toList())
.collect(Collectors.toSet())
.collect(Collectors.toMap())
.collect(Collectors.toCollection(~))

---

🤟🏻  Optional <T>

public final class Optional<T> {

	private final T vale;
    
 }

 : Null이 올 수 있는 값을 감싸는 wrapper 클래스 

- NPE(NullPointerException) : null 값으로 인해 에러가 발생하는 현상

 - Optional은 NPE가 발생하지 않도록 연산결과를 가지고 있다가 반환

 

  👉🏻 메서드가 반환할 결과 값이 없음을 명확히 표현할 필요가 있고

       null을 반환하면 에러가 발생할 가능성이 높은 상황에서 Optional 사용하는 것이 목적

 

1️⃣ orElse() / orElseGet() orElseThrow() 사용

  : 값이 null 일 때 이들을 활용하여 디폴트 값 지정 가능

.orElse(getId())
.orElseGet(this::getId)

  - orElse() : 파라미터로 값을 받음 & 값이 미리 존재하는 경우 사용

  - orElseGet() : 파라미터로 함수형 인터페이스를 받음 & 값이 미리 존재하지 않는 경우 사용

2️⃣ of()와 ofNullable()

Optional<String> one = Optional.ofNullable("123");
Optional<String> two = Optinal.of("123");

 - of()는 x가 null이 아님이 확실할 때만 사용

 - ofNullable()은 x가 null일 수도 있을때만 사용

3️⃣ empty()

Optional<String> three = Optional.empty();

  - 참조 변수를 기본값으로 초기화할 때 사용

  - Optional은 Wrapper클래스 이기 때문에 빈 값이 올 수 있음

 

4️⃣ get()

  - Optional 객체에 저장된 값을 가져오는 메소드

  - 값이 null 일 때 orElse() 등을 활용하여 디폴트 값 지정 가능