018 | Java - Enum, Annotation, Lambda, Stream

💙 Enum

🤍 History of Enum

• 서로 관련된 상수(변하지 않는 값, final)들의 집합
• 한정되어 변하지 않는 데이터를 다루는 데 사용

// 계절
public static final int SPRING = 1;
public static final int SUMMER = 2;
public static final int AUTUMN = 3;
public static final int WINTER = 4;

// 프레임워크
public static final int DJANGO  = 1;
public static final int SPRING  = 2;
// => 컴파일에러. 계절의 SPRING과 중복 발생!

interface Seasons {
	int SPRING = 1, SUMMER = 2, AUTUMN = 3, WINTER = 4;
}

interface Frameworks {
	int DJANGO = 1, SPRING = 2, NEST = 3, EXPRESS = 4;
}

⇒ 중복 상수명 문제는 피할 수 있지만 타입 안정성 문제가 생김

if(Seasons.SPRING == Frameworks.SPRING) { }

⇒ 의미적으로 다른 개념이지만, 위 둘을 비교하면 에러가 발생하지 않음.

이걸 해결해주려면 서로 다른 객체로 만들어줘야됨

class Seasons {
    public static final Seasons SPRING = new Seasons();
    public static final Seasons SUMMER = new Seasons();
    public static final Seasons FALL   = new Seasons();
    public static final Seasons WINTER = new Seasons();
}

class Frameworks {
    public static final Frameworks DJANGO  = new Frameworks();
    public static final Frameworks SPRING  = new Frameworks();
    public static final Frameworks NEST    = new Frameworks();
    public static final Frameworks EXPRESS = new Frameworks();
}

⇒ 상수명 중복, 타입 안정성 문제 해결 가능. But, 코드 길어짐. 사용자 정의타입이라 switch문에 사용 불가

이래서 나온게 enum

enum Seasons { SPRING, SUMMER, FALL, WINTER }
enum Frameworks { DJANGO, SPRING, NEST, EXPRESS }

🤍 Use Enum

열거형의 사용

enum 열거형이름 {상수명1, 상수명2, 상수명3, ...}

예시

eums Seasons {
	SPRING,  //정수값 0 할당
	SUMMER,  //정수값 1 할당
	AUTUMN,  //정수값 2 할당
	WINTER   //정수값 3 할당
}

• 열거형에 선언된 상수에 접근하는 방법: 열거형이름.상수명

enum Seasons { SPRING, SUMMER, AUTUMN, WINTER }

public class EnumExample {
    public static void main(String[] args) {
        System.out.println(Seasons.SPRING); // SPRING
    }
}

• 참조변수 favouriteSeason에 Seasons.SPRING 담기

enum Seasons { SPRING, SUMMER, AUTUMN, WINTER }

public class EnumExample {
    public static void main(String[] args) {
        Seasons favoriteSeason = Seasons.SPRING;
        System.out.println(favoriteSeason); // SPRING
    }
}

✅ Ref. 

https://docs.oracle.com/javase/7/docs/api/java/lang/Enum.html

Enum (Java Platform SE 7 )

💙 Annotation

🤍 About Annotation

• “정보를 전달해줄 대상”에 목적을 둠
• 프로그래밍 언어에 영향을 미치지 않으며 개발자/프로그램에게 정보 제공

애너테이션의 역할

• 컴파일러에게 정보 제공 ⇒ 문법 에러 체크
• 프로그램 빌드 시 정보 제공 ⇒ 코드 자동 생성
• 런타임에게 정보 제공 ⇒ 특정 기능 실행

애너테이션의 종류

• 표준 애너테이션: 자바에서 기본 제공
• 메타 애너테이션: 애너테이션에 붙이는 애너테이션
• 사용자 정의 애너테이션

🤍 표준 애너테이션 (*)

@Override

• 메서드 앞에만 붙일 수 있음
• 선언한 메서드가 상위 클래스의 메서드를 오버라이딩하는 메서드라는 것을 컴파일러에게 알려줌

class Super {
	void run() {}
}
class Sub extends Super {
	@Override
	void rnu() {} // 컴파일 에러 - 오타
}

@Deprecated

• 앞으로 사용하지 않을 것을 궈장하는 필드나 메서드에 붙임

class OldClass {
	@Deprecataed
	int oldField;

	@Deprecated
	int getOldField() { return oldField; }
}

❓왜 메서드를 없애는 것 대신 @deprecated를 사용할까?

❗자바는 하위 호환성을 중요시 여김. 하위 버전과 호환성 때문에 @deprecated를 사용하므로 앞으로는 사용하지 말라고 알려주는 것!

@SuppressWarnings

• 컴파일 경고 메시지를 제외시킬 때 사용
• @SuppressWarnings("all") // 모든 경고 제외
• 둘 이상의 경고를 한번에 제외
• @SuppressWarnings({"deprecation", "unused", "null"})

@FunctionalInterface

• 함수형 인터페이스를 선언할 때, 컴파일러가 함수형 인터페이스의 선언이 바르게 선언되었는 지 확인
  • 함수형 인터페이스: 단 하나의 추상 메서드만 가져야 함

  @FunctionalInterface
  public interface Runnable {
  	public abstract void run (); // 하나의 추상 메서드
  }
  

• 목적: 람다식 사용 (1:1 매칭)

🤍 메타 애너테이션

• 애너테이션을 위한 애너테이션 
• 애너테이션의 적용대상 또는 유지 기간을 정하는 등 애너테이션을 정의하는 데 사용

@Target

• 애너테이션 정의 시 적용 대상을 지정하는데 사용
• java.lang.annotation.ElementType
• 예시

import static java.lang.annotation.ElementType.*; 
//import문을 이용하여 ElementType.TYPE 대신 TYPE과 같이 작성 가능

@Target({FIELD, TYPE, TYPE_USE})	// 적용대상: FIELD, TYPE
public @interface CustomAnnotation { }	// 정의: CustomAnnotation

@CustomAnnotation	// 적용대상이 TYPE인 경우
class Main {
	@CustomAnnotation	// 적용대상이 FIELD인 경우
	int i;
}

@Documented

• 애너테이션에 대한 정보가 javadoc으로 작성한 문서에 포함되도록 하는 애너테이션 설정
• 자바에서 제공하는 표준 애너테이션과 메타 애너테이션 모두 @Documented가 적용
  (@Override @SuppressWarnings를 제외)

@Documented
@Target(ElementType.Type)
public @interface CustomAnnotation { }

@Inherited

• 하위 클래스가 애너테이션을 상속 ⇒ 상위 클래스에 붙은 애너테이션들이 동일하게 적용

@Inherited // @SuperAnnotation이 하위 클래스까지 적용
@interface SuperAnnotation{ }

@SuperAnnotation
class Super { }

class Sub extends Super{ } // Sub에 애너테이션이 붙은 것으로 인식

@Retention

• 애너테이션의 지속 시간 결정
• 애너테이션 유지정책(유지되는 기간 지정 속성)
  • SOURCE: 소스 파일에 존재. 클래스 파일에는 존재하지 않음
  • CLASS: 클래스 파일에 존재. 실행 시 사용불가, 기본값
  • RUNTIME: 클래스 파일에 존재. 실행 시 사용 가능

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE) 
//오버라이딩이 제대로 되었는지 컴파일러가 확인하는 용도 
//클래스 파일에 남길 필요 없이 컴파일시에만 확인하고 사라짐
public @interface Override(){ }

⇒ 위 예제에서 @Override는 컴파일러 사용 후 끝 ⇒ 실행 시 사용 x

@Repeatable

• 애너테이션 반복 사용 가능
• 사용자 타입 애너테이션 정의

@Repeatable(Works.class) // ToDo 애너테이션을 여러 번 반복해서 쓸 수 있게 한다.  
@interface Work{  
    String value();  
}

• 반복 사용

@Work("코드 업데이트")  
@Work("메서드 오버라이딩")  
class Main{ }

• 여러번 적용 가능 ⇒ 하나로 묶어주는 별도 애너테이션 작성 필요

@interface Works {  // 여러개의 ToDo애너테이션을 담을 컨테이너 애너테이션 ToDos
    Work[] value(); 
}

@Repeatable(Works.class) // 컨테이너 애너테이션 지정 
@interface Work {
	String value();
}

🤍 사용자 정의 애너테이션

• 사용자 직접 정의해서 사용

@interface 애너테이션명 { // 인터페이스 앞에 @기호를 붙여 정의 
	타입 요소명(); // 애너테이션 요소 선언
}

• java.lang.annotation 인터페이스를 상속받기 때문에 다른 클래스나 인터페이스를 상속 받을 수 없음

✅ Ref. 

https://docs.oracle.com/javase/tutorial/java/annotations/index.html

Lesson: Annotations (The Java™ Tutorials > Learning the Java Language)

💙 Lambda

🤍 람다식

• 메서드를 하나의 식으로 표현한 것 ⇒ 코드 간결, 명확
• 함수형 프로그래밍 기법 지원

//기존 메서드 표현 방식
void sayhello() {
	System.out.println("HELLO!")
}

//위의 코드를 람다식으로 표현한 식
() -> System.out.println("HELLO!")

• 특징
  • 반환타입과 이름 생략 가능 ⇒ 익명함수(anonymous function)
  • 메서드 바디에 실행문이 하나만 존재할 경우 중괄호 생략 가능
  • 매개변수 타입 유추 가능할 경우 매개변수 타입 생략 가능
  • 익명객체 → 선언과 동시에 생성

🤍 함수형 인터페이스

• 자바에서 함수는 반드시 클래스 안에서 정의 ⇒ 메서드 독립적 x
• 람다식 → 객체 ⇒ 이름이 없기 때문에 익명 클래스
  • 익명클래스: 객체의 선언과 생성을 동시에 함
    ⇒ 단 하나의 객체만 생성하고 단 한번만 사용되는 일회용 클래스

public class LamdaEx {
    public static void main(String[] args) {
		   /* Object obj = new Object() {
            int sum(int num1, int num2) {
                return num1 + num1;
            }
        };
			*/ 
		FunctionEx exFunction = (num1, num2) -> num1 + num2
		System.out.println(exFunction.sum(10,15))
}

@FunctionalInterface // 인터페이스가 바르게 정의되었는지 컴파일러가 확인할 수 있게 ..
interface FunctionEx {
		public abstract int sum(int num1, int num2);
}

• 기존 인터페이스 문법을 활용하여 람다식을 다루는 것
  • 가능한 이유? 람다식도 결국 하나의 객체이기 때문 → 인터페이스에 정의된 추상메서드 구현 가능
• 람다식 : 인터페이스 메서드 = 1 : 1

@FunctionalInterface
public interface FunctionalInterface {
    public int accept(int x, int y);
}

import static java.lang.Integer.sum;

public class FunctionalInterfaceEx {
    public static void main(String[] args) throws Exception {
        FunctionalInterface ex;

        ex = (x, y) -> {
            int result = x + y;
            return result;
        };
        ex = (x, y) -> { return x + y; };
        ex = (x, y) -> x + y;
        ex = (x, y) -> sum(x, y);
    }

    public static int sum(int x, int y){
        return x + y;
    }
}

/* 출력: 다 7*/

🤍 메서드 레퍼런스

• 람다식에서 불필요한 매개변수를 제거할 때 주로 사용
  ⇒ 람다식으로 간단해진 익명 객체를 더! 간단하게! 사용

(left, right) -> Math.max(left, right);

// 위의 메서드를 참조 메서드로 변경
// 클래스이름 :: 메서드이름
Math :: max

정적 메서드와 인스턴스 메서드 참조

• 정적 메서드 참조

클래스 :: 정적메서드명

• 인스턴스 메서드 참조

참조변수 :: 인스턴스메서드명

 예시

// Calculator.java

public class Calculator {
    public static int staticMethod(int x, int y) {
        return x + y;
    }

    public int instanceMethod(int x, int y) {
        return x * y;
    }
}

import java.util.function.IntBinaryOperator;

public class MethodReferences {
    public static void main(String[] args) {
        IntBinaryOperator operator;

        /*  정적메서드
         * 클래스이름 :: 메서드이름
         */
        operator = Calculator::staticMethod;
        System.out.println("정적메서드: " + operator.applyAsInt(3, 5));

        /*  인스턴스메서드
         * 인스턴스이름 :: 메서드이름
         */
        Calculator calculator = new Calculator();
        operator = calculator::instanceMethod;
        System.out.println("인스턴스메서드: " + operator.applyAsInt(3, 5));
    }
}

생성자 참조

• 생성자 참조 == 객체생성
• 객체 생성 & 리턴 람다식 ⇒ 생성자 참조로 대치 가능

(a, b) -> { return new 클래스(a, b); };

• 생성자 참조로 표현

클래스 :: new

✅ Ref. 

• 함수형 인터페이스 스펙 확인

https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

java.util.function (Java Platform SE 8 )

https://codechacha.com/ko/java8-functional-interface/

Java8 - 함수형 인터페이스(Functional Interface) 이해하기

💙 Stream

🤍 Stream 특징

• 스트림: 데이터를 연속적으로 전달하는 통로
• 배열, 컬렉션의 저장요소를 하나씩 참조해서 람다식으로 처리할 수 있도록 해주는 반복자
• 다양한 데이터 소스(List, Set, Map, 배열 등)로부터 스트림을 만들고, 표준화된 방법으로 다룰 수 잇음

선언형으로 데이터 소스 처리

• “무엇"을 수행하는지가 중요
• 내부 동작 원리를 몰라도 코드가 무슨 일을 하는지 이해 가능

예시

• List에 있는 숫자들 중 4보다 큰 짝수 합계 구하기

import java.util.List;

public class ImperativeProgrammingEx{
    public static void main(String[] args){
        List<Integer> numbers = List.of(1, 3, 6, 7, 8, 11);

	// 명령형 프로그래밍
        int sum = 0;
        for(int number : numbers) {
            if(number > 4 && (number % 2 == 0)) {
                sum += number;
            }
        }

        // 선언형 프로그래밍 - 스트림
        int sum = numbers.stream()
                         .filter(number -> number > 4 && (number % 2 == 0))
                         .mapToInt(number -> number)
                         .sum();
    }
}

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

• 스트림이 제공하는 대부분의 요소 처리 메서드 ⇒ 함수형 인터페이스 매개타입을 가짐
• ⇒ 람다식 또는 메서드 참조를 이용해서 요소 처리 내용을 매개값으로 전달할 수 있음

stream.forEach(s -> {
    String name = s.getName();
    int score = s.getScore();
    System.out.println(name + ": " + score);
});

내부 반복자의 사용으로 병렬 처리에 용이

• 외부반복자(external iterator)
  • 개발자가 코드로 직접 컬렉션의 요소를 반복해서 가져오는 코드 패턴
  • index를 사용하는 for문, iterator를 이용하는 while문
• 내부반복자(internal iterator)
  • 컬렉션 내부: 요소 반복 / 개발자: 요소 당 처리해야 할 코드만 제공하는 코드 패턴
  • 이점
    • 요소 반복은 컬렉션에게, 개발자는 요소 처리 코드에 집중
    • 요소 반복 순서 변경, 멀티코어 CPU 최대한 활용
      ⇒ 요소들을 분배시켜 병렬 작업을 도와주므로 효율적인 요소 반복 가능
      • 병렬 스트림 사용: 스트림 parallel() 메서드 사용

중간 연산과 최종 연산

• 스트림은 컬렉션의 요소에 대해 중간 연산과 최종 연산을 수행할 수 있음
  • 중간 연산: 매핑, 필터링, 정렬 등을 수행
  • 최종 연산: 반복, 카운팅, 평균, 총합 등의 집계 수행
• 예를 들어 학생 객체를 요소로 가지는 컬렉션이 있다고 가정할 때,
  • 중간 연산: 학생의 점수를 출력
  • 최종 연산: 점수의 평균값을 산출

🤍 파이프라인

• 리덕션(Reduction): 대량의 데이터를 가공해 축소하는 것
  • 결과물: 데이터의 합계, 평균값, 카운팅, 최대값, 최소값 등

파이프라인

• 구조: 여러개의 스트림이 연결
• 모두 중간 연산 스트림(최종 연산 제외)

중간 스트림이 생성될 때 요소들이 바로 중간 연산(필터링, 매핑, 정렬)되는 것이 아니라 최종 연산이 시작되기 전까지는 지연되고, 최종 연산이 시작될 때 컬렉션의 요소가 하나씩 중간 스트림에서 연산되고 최종 연산까지 오게 됨

🤍 스트림 생성, 중간 연산, 최종 연산

스트림 생성

• stream(): Collection 인터페이스에 정의
  ⇒ Collection 인터페이스 구현 객체(List, Set 등)들은 모두 이 메서드로 스트림 생성 가능
• stream() 사용 ⇒ 해당 Collection의 객체 소스로 하는 Stream 반환
• 스트림 사용 시 주의점
  • Read-only
  • Disposable

중간 연산

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

필터링 - filter(), distinct()

• filter(): 스트림 조건에 맞는 데이터만 필터링
• distinct(): 스트림 요소 중복 제거

매핑 - map()

• map(): 기존 Stream 요소 → 새로운 Stream 대체
  ⇒ 스트림의 스트림 반환
• flatMap(): 요소를 대체하는 복수 개의 요소들로 구성된 새로운 스트림 리턴
  ⇒ 스트림 반환

정렬 - sorted()

• Stream 요소 정렬
• 파라미터로 Comparator 넘기기 가능
  • 오름차순: Comparator 인자 없이 호출
  • 내림차순: reverseOrder 사용

list.stream()
    .sorted()	// 오름차순
    .forEach(n -> System.out.println(n));
System.out.println();

list.stream()
    .sorted(Comparator.reverseOrder())	// 내림차순
    .forEach(n -> System.out.println(n));

연산 결과 확인 - peek()

• 연산 중간에 결과를 확인하여 디버깅하려고 할 때 사용

intStream
	.filter(a -> a%2 ==0)
	.peek(n-> System.out.println(n))
	.sum();

최종 연산

연산 결과 확인 - forEach()

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

intStream
	.filter(a -> a%2 ==0)
	.forEach(n -> System.out.println(n));

매칭 - match()

• Stream 요소들이 특정한 조건을 충족하는지 검사
• 함수형 인터페이스 Predicate로 해당 조건을 만족하는지 검사 → boolean 반환
• 종류
  • allMatch(): 모든 요소들이 매개값으로 주어진 Predicate 조건을 만족하는지 검사
  • anyMatch(): 최소한 한 개의 요소가 매개값으로 주어진 Predicate 조건을 만족하는지 검사
  • noneMatch(): 모든 요소들이 매개값으로 주어진 Predicate의 조건을 만족하지 않는지 검사

int[] intArr = {2,4,6};
boolean result = Arrays.stream(intArr).allMatch(a -> a % 2 == 0);
System.out.println("모두 2의 배수인가? " + result);			// true

result = Arrays.stream(intArr).anyMatch(a -> a % 3 == 0);
System.out.println("하나라도 3의 배수가 있는가? " + result);		// true

result = Arrays.stream(intArr).noneMatch(a -> a % 3 == 0);
System.out.println("3의 배수가 없는가? " + result);			// false

기본 집계 - sum(), count(), average(), max(), min()

• 요소들을 연산하여 하나의 값으로 산출하는 것

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

long count = Arrays.stream(intArr).count();
System.out.println("intArr의 전체 요소 개수: " + count);

long sum = Arrays.stream(intArr).sum();
System.out.println("intArr의 전체 요소 합: " + sum);

double avg = Arrays.stream(intArr).average().getAsDouble();
System.out.println("전체 요소의 평균값: " + avg);

int max = Arrays.stream(intArr).max().getAsInt();
System.out.println("최대값: " + max);

int min = Arrays.stream(intArr).min().getAsInt();
System.out.println("최소값: " + min);

int first = Arrays.stream(intArr).findFirst().getAsInt();
System.out.println("배열의 첫번째 요소: " + first);

다양한 집계 결과물 - reduce()

• 누적하여 하나로 응축(reduce)하는 방식
• 앞의 두 요소의 연산 결과를 바탕으로 다음 요소와 연산
  • Accumulator: 각 요소를 계산한 중간 결과를 생성하기 위해 사용
  • Identity: 계산을 수행하기 위한 초기값
  • Combiner: 병렬 스트림(Parlallel Stream)에서 나누어 계산된 결과를 하나로 합침

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

long sum = Arrays.stream(intArr).sum();
System.out.println("intArr의 전체 요소 합: " + sum);

int sum1 = Arrays.stream(intArr)
                .map(el -> el*2)
                .reduce((a,b) -> a+b)
                .getAsInt();
System.out.println("초기값 없는 reduce: " + sum1);

int sum2= Arrays.stream(intArr)
                .map(el -> el*2)
                .reduce(0, (a,b) -> a+b);
System.out.println("초기값 존재하는 reduce: " + sum2)

Stream요소 다른 종류로 수집 - collect()

• Stream의 요소들을 다른 종류(List, Set, Map 등)의 결과로 수집
• 일반적으로 List로 Stream의 요소들을 많이 수집
  ⇒ 자주 사용하는 작업은 Collectors 객체에서 static 메서드로 제공
  ⇒ 원하는 것이 없으면 Collector 인터페이스를 직접 구현하여 사용

🤍 Optional<T>

• NullPointerException(NPE)에서 null 값으로 인해 에러가 발생하는 현상을 객체 차원에서 효율적으로 방지하고자 도입
• 연산 결과를 Optional에 담아서 반환하면, 따로 조건문을 작성하지 않아도 NPE가 발생하지 않도록 코드작성 가능

Optional 객체 생성

• of() 사용
• 참조변수의 값이 null일 가능성이 있다면 ofNullable() 사용

Optional<String> opt1 = Optional.ofNullable(null);
Optional<String> opt2 = Optional.ofNullable("123");
Optional<String> opt3 = Optional.<String>empty();  // 기본값으로 초기화

메서드 체이닝

• 여러 메서드를 연결해서 작성

✅ Ref. 

• Optional 객체에서 제공하는 전체 메서드

https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html

Optional (Java Platform SE 8 )

💜 오늘의 생각 조각모음

• 메서드 레퍼런스는 람다식으로 간단해진 익명객체를 더 간단하게 사용하는 것이다. 간단해진 익명 객체를 더! 간단!하게!! 인간의 욕심은 끝이 없고 … 나는 무슨말인지 모르겠고 … 😵‍💫
• I/O는 내일 ... ㅠ.ㅠ