🌈 [Section1] 17. Java 심화1

📕 오늘 배운 내용!

• 애너테이션 (Annotation)
• 람다식
• 스트림 (Stream)

---

✏️ 애너테이션 (Annotation)

• 특정 프로그램에게 어떠한 정보를 제공하기 위한 것

💡 Comment와 Annotation (둘 다 주석)

• 정보를 전달하는 대상에 차이가 있음
• Comment는 개발자가 개발하면서 참고하기 위해 (코딩할 때 주로 사용하는 주석)
  ( 코드 실행에 영향 X )

✏️ 애너테이션의 종류

✔ 표준 애너테이션

• @Override
  상위클래스의 메서드를 오버라이딩 한 하위 메서드에서 이름이 같지 않거나 런타임에러가 발생할 때 빨간줄로 에러를 발생시켜줌
  (오버라이딩할 메서드 앞에만 붙일 수 있음)
  (안붙여도 무관하지만 그냥 정보 주는 것)

• @Deprecated
  새로운 버전이 있어 대체되었으니 이 기존의 것을 사용하지 마라

• @FunctionalInterface
  함수형 인터페이스 선언 시에 이 선언이 바르게 되었는지 확인하고 아닌 경우 에러 발생시켜줌
  ( 코드 작성시 실수 방지를 위한 확인용 애너테이션 )

• @SuppressWarning
  컴파일 경고 메세지가 나타나지 않게 해라
  ( 뒤에 괄호를 붙여 그 안에 어떤 경고를 억제할 지 쓸 수 있음 )

✔ 메타 애너테이션

특정 애너테이션의 적용 대상 유지 기간 등을 다시 관리하기 위한 애너테이션

• @Target({})
  중괄호 안에 애너테이션 적용 대상 지정

• @Documented
  애너테이션 정보를 javadoc 문서에 포함되도록 함
  (@Overfide, @SuppressWarning 빼고 모두 이 애너테이션이 적용되어 있음)

• @Inherited
  해당 클래스의 하위클래스에도 애너테이션 상속받도록함

• @Retention
  특정 애너테이션의 지속 시간 결정
  -> 얼마나 유지될지 < SOURCE (소스파일에 존재) / CLASS (기본값) / RUNTIME (실행시 사용) > 로 결정

• @Repeatable
  애너테이션 여러번 붙일 수 있도록 허용
  (여러개 적힌 애너테이션들을 하나로 묶어주는 애너테이션도 별도로 작성해야함)

✔ 사용자 정의 애너테이션

사용자가 직접 애너테이션 정의 후 사용하는 것

@interface 애너테이션 명 { //애너테이션 정의
	타입 요소명(); //애너테이션 요소 선언
}

---

✏️ 람다식

• 메서드를 간략하게 표현하기 위한 문법 요소 ( 더 똑똑하고 더 간편한 코드를 위해!! )
  ( 메소드를 참조해서 매개 변수의 정보 및 리턴 타입을 알아내어, 람다식에서 불필요한 매개 변수를 제거 )

• Stream 사용에 활용

• 익명객체(익명클래스) 👉 반환타입 / 이름 생략 가능

  💡 익명클래스란?

  • 객체의 선언과 생성을 동시에 하여 오직 하나의 객체를 생성하고, 단 한번만 사용되는 일회용 클래스

• 반환값이 있는 메서드의 경우 👉 return문 / 세미콜론(;) 도 생략 가능

• 매개변수 타입을 쉽게 유추할 수 있는 경우 👉 매개변수 타입도 생략 가능

Ex. ⬇️ 람다식 사용

// 기존 방식
void example (String str) {
	System.out.println(str);
}
----------------------------------------------------------------------------------
// 람다식
(String str) -> { System.out.println(str);}

Ex. ⬇️ 특정 조건을 충족한 경우

//기존 방식
int sum(int num1, int num2) { //매개변수의 타입 쉽게 유추 가능
	return num1 + num2; //반환타입이 있음
}
----------------------------------------------------------------------------------
// 람다식
(num1, num2) -> num1 + num2 //실행문 하나만 존재해 {}생략

✔ 함수형 인터페이스 (Functional Interface)

• 람다식을 객체처럼 다루기 위해 사용하는 인터페이스
  ( 기존의 인터페이스 문법을 활용하여 람다식을 다루는 것 )

• 함수형 인터페이스에는 단 하나의 추상메서드만 선언
  ( 람다식과 인터페이스의 메서드는 1:1로 매칭되기 때문 )

👉 1. 매개변수와 리턴값이 없는 람다식 (매개변수, 리턴값이 없는 추상메서드를 가진 함수형 인터페이스)

//기존 방식
public interface Example {
	public void accept();
}
----------------------------------------------------------------------------------
//람다식
Example ex1 = () -> { ... } //실행문이 하나면 {} 생략 가능

ex1.accept(); 메서드 호출 ➜ { ... } 의 내용이 출력됨

👉 2. 매개변수가 있는 람다식 (매개 변수가 있고 리턴값이 없는 추상 메서드를 가진 함수형 인터페이스)

//기존 방식
public interface Example {
	public void accept(int x);
}
----------------------------------------------------------------------------------
//람다식
Example ex1 = (x) -> { ... } //실행문이 하나면 {} 생략 가능

ex1.accept(x에 대입될 수); 메서드 호출 ➜ { ... } 의 내용이 출력됨

👉 3. 리턴값이 있는 람다식 (매개 변수와 리턴값을 가지는 추상 메서드를 포함하는 함수형 인터페이스)

//기존 방식
public interface Example {
	public int accept(int x, int y); //void가 아닌 int -> 리턴값 O
}
----------------------------------------------------------------------------------
//람다식
Example ex1 = (x) -> { ... }
//return 값 있어야함 //실행문이 하나일 경우 {}, return값 생략 가능

ex1.accept(x, y에 대입될 수); 메서드 호출 ➜ { ... } 의 내용이 출력됨

✔ 메서드 참조 (Method Reference)

• 람다식 보다 더 간단하게 하고싶을 때 인스턴스의 메서드를 참조하기 위해 사용
  (클래스들을 모두 작성 후 Main 메서드에서 사용)

//람다식
String name =
memberList.stream().map(element -> element.getName()).collect(Collectors.toList());
--------------------------------------------------------------------------
//메서드 참조 표현식
String name =
memberList.stream().map(Member::getName()).collect(Collectors.toList());

➜ 람다식의 인스턴스 -> 인스턴스.메서드명을 메서드 참조 표현으로
인스턴스의 클래스명::메서드명 으로 변경

• 기본 메서드 참조 ➜ 클래스명 :: 메서드명 ( 클래스명.메서드명 과 같은 맥락 )

• 정적메서드 참조 ➜ 클래스명 :: 정적 메서드명 ( 클래스명.정적메서드명 과 같은 맥락 )

• 인스턴스 메서드 참조 ➜ (생성한 인스턴스의)참조 변수명 :: 인스턴스 메서드명

✔ 생성자 참조 (Constructor Reference)

• 생성자를 참조한다 = 객체 생성 ➜ 클래스명 :: new ( 객체 생성했을 때 오른쪽 생성자 )

• 생성자가 오버로딩되어 여러개 있을 경우 ➜ 함수형 인터페이스의 추상메서드와 동일한 매개변수 타입과 개수 가지고 있는 생성자 찾아 실행

//람다식
List<Member> memberList =
memberNameList.stream().map(name -> new Member(name)).collect(Collectors.toList());
-----------------------------------------------------------------------------------
//메서드 참조 표현식
List<Member> memberList =
memberNameList.stream().map(Member::new).collect(Collectors.toList());

➜ 람다식의 (리스트의 인자로 들어갈 객체 -> new 클래스명(인자로 들어갈 객체))를
메서드 참조 표현으로 (클래스명::new) 으로 변경

---

✏️ 스트림 (Stream)

• 다양한 데이터 소스(컬랙션/배열)를 표준화하여 통합된 방식으로 다루는 선언형 프로그래밍 방식

• Collection 인터페이스 안에 정의되어있기 때문에 구현 객체들(List, Set, Map) 모두 스트림 사용 가능 (배열도 사용 가능)

• 데이터 소스로부터 데이터를 읽기만 할 뿐 변경 X ( Read-only )
  ( 원본을 변경하지 않아 원본에 영향 X )

• 스트림은 일회용 (one-time only)
  ( 한 번 사용하면 닫힘 ➜ 필요하다면 새로운 스트림을 만들어야함 )

• < 스트림 생성 / 중간 연산 / 최종 연산 > 이 세 단계로 구성

💡 컬렉션 vs 스트림

• 공통점
  ➜ 연속된 요소형식의 값을 저장하는 자료구조 인터페이스를 제공
  ➜ 둘다 순차적으로 요소에 접근
  ⠀
• 차이점
  • 컬렉션
    ➜ 각 계산식을 만날 때마다 데이터가 계산
    ➜ 데이터의 접근, 읽기, 변경, 저장이 주요 목적
    ➜ 데이터에 접근하는 방법을 직접 작성
    ➜ Iterator로 모든요소를 순환
    ➜ 메모리에 모든 요소가 올라가 있는 상태에서 요소들을 누적시키며 결과를 계산
    ➜ 메모리 사용량이 늘어남
    ⠀
    👉 물을 한번에 마시는 건 컬렉션
    ⠀
  • 스트림
    ➜ 최종 연산이 실행 될 때에 데이터가 계산
    ➜ 계산식(람다)을 표현하는 것이 주요 목적
    ➜ 데이터에 접근하는 방법이 추상화되어있음
    ➜ 계산식을 미리 적어두고 계산시에 람다식으로 JVM에 넘김
    ➜ 내부에서 요소들을 어떻게 메모리에 올리는 지는 상관 X
    ➜ 메모리 사용량이 줄어듦
    ➜ 대용량 데이터의 가공처리 가능
    ( 많은 데이터를 병렬로 쪼개서 동시에 한번에 처리하기 때문에 )
    ⠀⠀
    👉 물을 꿀꺽꿀꺽 단계에 맞춰 마시는 건 스트림

---

✔ 스트림의 특징

• 선언형으로 데이터 소스 처리
  (내부동작 원리를 몰라도 선언되어있는 코드를 보고 코드가 무슨 일 하는지 이해 가능)

• 람다식으로 요소 처리 코드 제공

• 내부 반복자를 사용하여 병렬처리가 쉬움 (병렬 스트림 - parallel()메서드 사용 )

• 중간 연산과 최종 연산을 할 수 있음

💡 반복자 종류
⠀
1. 외부 반복자 (external iterator)

• 개발자가 코드로 직접 컬렉션의 요소를 반복해서 가져오는 코드 패턴
  (컬렉션에서 사용하던 iterator)

2. 내부 반복자 (internal iterator)

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

💡 병렬처리란?

• 한 가지 작업을 서브 작업으로 나누고, 서브 작업들을 분리된 스레드에서 병렬적으로 처리하는 것

✔ 리덕션(Reduction)

대량의 데이터를 가공해서 축소하는 것
-> 데이터의 합계, 평균값, 카운팅, 최대값, 최소값 등이 대표적인 결과물

✔ 파이프라인(pipelines)

• 중간연산, 최종연산의 여러개의 스트림들이 연결되어있는 구조
  ( 스트림이 중간연산과 최종연산을 이 파이프라인으로 처리함 )
  

💡 명령형 프로그래밍 vs 선언형 프로그래밍

• 명령형은 if / for문
• 선언형은 stream
  ( 체인처럼 나열되어 있어서 체인형이라고 하기도 함 )
  ⠀
  ➜ 각 장점이 있으니 상황에 맞추어 잘 사용하기 !

---

✏️ 스트림 순서

1. 스트림 생성

• stream() 사용하여 Collection 객체를 소스로 하는 Stream 반환
• 객체의 참조변수명.stream()

2. 중간 연산

• 연속해서 여러번 수행 가능 ( 여러번 수행한 결과는 스트림 )

  주요 메서드

  • 필터링
    distinct() ➜ 중복 제거
    filter() ➜ Stream 조건이 참이 되는(조건이 맞는) 데이터만 추출
    ⠀
  • 매핑
    map()
    ➜ 기존 Stream 요소들을 대체하는 요소로 구성된 새로운 Stream 형성하는 연산
    ➜ 지정된 값을 특정한 형태로 변환하는데 주로 사용
    Ex. 모든 요소들을 대문자로 바꾸기
    ➜ Stream의 Stream을 반환
    flatMap() ➜ Stream을 반환
    Ex. Srting 객체들의 스트림이 두개가 있을 때, 그것들을 여러 배열의 요소들을 flat하게 한 배열에 몰아서 만들어준다텍스트
    ⠀
  • 정렬
    sorted() ➜ 오름차순 정렬
    sorted(Comparator.reverseOrder()) ➜ 내림차순 정렬
    ⠀
  • 연산 결과 확인
    peek() ➜ 연산 중간 결과를 확인하여 디버깅 하고자할 때 사용
    ⠀
  • 스트림 두개 합치기
    concat() ➜ 괄호 안에 합칠 stream의 참조값들을 넣으면 합쳐짐

3. 최종 연산

• 한번만 연산 가능 (일회용)

  주요 메서드

  • 연산 결과 확인
    forEach() ➜ 파이프라인 마지막에서 요소를 하나씩 연산
    ⠀
    매칭
    match() ➜ Stream 요소들이 특정 조건을 충족하는지 검사
    ( Predicate(함수형 인터페이스) 받아서 조건 검사 후, 결과 boolean으로 반환 )
    ➜ allMatch() - 모든 요소 만족하는지
    ➜ anyMatch() - 최소 하나라도 만족하는지
    ➜ noneMatch() - 모든 요소 만족하지 않는지
    ⠀
    집계
    sum() ➜ 모든 요소 총 합
    count() ➜ 요소의 개수 ( long 타입의 수 반환 )
    average() ➜ 평균 ( 각 기본타입으로 래핑된(래퍼클래스) Optional 객체 반환 )
    max() ➜ 최대값 ( 가장 큰 값 가지는 요소를 참조하는 Optional 객체 반환 )
    min() ➜ 최소값 ( 가장 작은 값 가지는 요소를 참조하는 Optional 객체 반환 )
    reduce()
    ➜ 누적하여 하나로 응축(reduce)하는 방식
    ( 앞의 두 요소의 연산결과를 누적하여 다음 요소와 연산 )
    ➜ 최대 3개 매개변수 받을 수 있음
    collect()
    ➜ Stream의 요소들을 List, Set, Map, 등 다른 종류의 결과로 수집하고 싶은 경우
    ➜ Stream 요소들을 어떻게 수집할 것인가를 정의한 Collector 타입을 인자로 받음
    ➜ Collector 인터페이스를 구현한 클래스
    Ex. collect(Collectors.toList()) -> 컬렉션 중 List로 수집
    ( Collectors 객체의 toList() 메서드를 가져와 리스트로 만든다 )
    Ex. collect(Collectors.toCollection(LinkedList::new)) -> LinkedList로 수집
    ( Collections 객체의 Collections 에서 LinkedList의 객체를 가져와 만든다 )
    ⠀
    [참고] https://napasun-programming.tistory.com/39?category=743853

💬 여기서 내가 궁금했던 점 !!
문제를 풀 때 어떤 애들은 mapToInt를 사용하고 어떤 애들은 getAsInt를 사용하던데 그 차이가 무엇일까?
mapToInt - Stream 자체를 IntStream(기본형 스트림)으로 변환하는 것 ( 반대는 mapToObj() / boxed() )
getAsInt - Optional클래스의 결과값을 Int 타입으로 가져오는 것
⠀
[참고] https://ryan-han.com/post/dev/java-stream/
[참고] https://wickies.tistory.com/14

💡 peek( ) 와 forEach( )

• 공통점
  요소를 하나씩 돌며 출력한다는 점
  ⠀
• 차이점
  • peek()
    -> 중간 연산 메서드
    -> 하나의 스트림에 여러번 사용 가능
  • forEach()
    -> 최종 연산 메서드
    -> 일회용 호출 (재호출 하려면 새 스트림 만들어야함)

✏️ Optional< T >

• T 타입 객체의 래퍼(Wrapper) 클래스
• 모든 타입의 객체를 담을 수 있는 래퍼(Wrapper) 클래스인 Optional 클래스에 연산 결과를 담아 반환하여 NullPointerException(NPE)가 발생하지 않도록 하는 것
• 변환할 결과값니 없음을 명확하게 표현하기 위해
• orElse(기본값) - Optional 객체에 저장된 값이 null 일 때 적은 기본값 반환
• orElseGet(타입::new) - Optional 객체에 저장된 값이 null 일 때 적은 객체 반환
• getAs타입() 으로 값 얻음

---

🌈 느낀점

이해하기 힘들었지만 코드를 쓰면서 그래도 조금씩 이해했다 아직까지는 stream의 사용법을 정확히는 파악할 수 없지만 페어와 문제 풀면서 익혀야겠다!!