TIL - 애너테이션, 람다, stream

드디어 오늘 stream을 배웠다!! ㅋㅋ 혼자 공부할 때 stream을 정리해보기로 하고 계속 미뤘었는데 정리된 내용으로 배우니 확실히 이해하기도 쉽고, 좋았다 ㅋㅋ 람다와 stream 역시 연습으로 체화시켜야겠다.😁

 

 

 

❓Annotation란?

주석과 비슷한 애너테이션은 정보 전달을 목적으로 만들어진 문법 요소로, 주석은 개발자, 즉 사람에게 정보를 전달하는 거라면 애너테이션은 compiler, 다른 프로그램에게 정보를 전달한다. (ex. @Override)

 

 

 

❓애너테이션의 종류는 무엇이 있는가?

JDK에서 제공하는 애너테이션과 다른 프로그램에서 제공하는 애너테이션으로 나뉘며, 전자는 표준 애너테이션, 후자는 메타 애너테이션이라 한다.

 

 

 

❓표준 애너테이션 알아보기

• @Override : 메서드 앞에만 붙일 수 있는 애너테이션으로 선언한 메서드가 상위 클래스의 메서드를 오버라이딩하거나 추상 메서드를 구현하는 메서드라는 것을 컴파일러에게 알려주는 역할
• @Deprecated : 기존에 사용하던 기술이 다른 기술로 대체되어 기존 기술을 적용한 코드를 더 이상 사용하지 않도록 유도하는 경우에 사용함.
• @SuppressWarnings : 컴파일 경고 메시지가 나타나지 않도록 함. 경우에 따라 경고가 발생할 것이 충분히 예상됨에도 묵인해야 할 경우 사용함.
• @FunctionalInterace : 함수형 인터페이스를 선언할 때, 컴파일러가 함수형 인터페이스의 선언이 바르게 되었는지 확인하도록 함. 

 

 

 

❓메타 애너테이션 알아보기

애너테이션을 정의하는 데에 사용되는 애너테이션으로 애너테이션의 적용 대상 및 유지 기간을 지정하는 데 사용됨.

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

• @Target : 애너테이션을 적용할 대상을 지정
• @Documented : 애너테이션에 대한 정보가 javadoc으로 작성한 문서에 포함되도록 하는 애너테이션 설정
• @Inherited : 하위 클래스가 애너테이션을 상속받도록 함
• @Retention : 애너테이션의 지속 시간을 결정하는 데 사용. 
• @Repeatable : 애너테이션을 여러 번 붙일 수 있도록 허용

 

 

 

❓사용자 정의 애너테이션 알아보기

사용자가 직접 애너테이션을 정의해서 사용

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

 

 

 

❓Lambda Expression이란?

람다식은 함수형 프로그래밍 기법을 지원하는 자바의 문법 요소로, 람다식은 메서드를 하나의 식으로 표현한 것.

자바는 JDK 1.8 이후 람다식 등 함수형 프로그래밍 문법 요소를 도입함. (람다식을 이용하면 기존의 객체지향 프로그래밍과 함수형 프로그래밍을 혼합하는 방식으로 보다 효율적인 프로그래밍을 할 수 있다)

 

 

 

 

❓함수형 인터페이스

람다식은 객체지향적 언어의 특성을 가진 자바의 특성에 따라 일반적인 함수가 아니라 익명의 객체이기 때문에 함수형 인터페이스를 이용하면 기존 자바의 문법 요소를 해지지 않으면서 함수형 프로그래밍 기법을 사용할 수 있다.

 

 

 

 

❓람다식 기본 문법

//기존 메서드 표현 방식
void sayHello(){
	System.out.println("Hello");
}
//위의 코드를 람다식으로 표현한 식
() -> System.out.println("Hello");

람다식은 기본적으로 반환타입과 이름을 생략할 수 있음. 즉, 람다함수를 종종 이름이 없는 함수, 즉 익명 함수라 부르기도 함. 메서드 바디에 실행문이 하나만 존재할 때 중괄호, return 문 생략 가능(세미콜론까지)

매개변수 타입도 생략 가능

public static void main(String[] args) {
    (int n1,int n2)-> {return n1+n2;}//반환 타입과 메서드명 제거, 화살표 추가
		//(int n1,int n2)-> n1+n2 //더 축약 가능
}
    
static int sum(int num1, int num2){ 
    return num1+num2;
}

 

 

 

 

❓함수형 인터페이스 사용

함수형 인터페이스에는 단 하나의 추상 메서드만 선언될 수 있는데, 이는 람다식과 인터페이스의 메서드가 1:1로 매칭되어야 하기 때문.

package codeStates;

public class LambdaExample {
    public static void main(String[] args) {
        SumFunction s = (n1, n2) -> n1 + n2;
        System.out.println(s.sum(2,3));

    }

    @FunctionalInterface
    interface SumFunction{
        int sum(int num1, int num2);
    }
}

 

 

 

❓자바에서 기본적으로 제공하는 함수형 메서드

마지막으로 자바에서는 빈번하게 사용되는 함수형 인터페이스를 기본적으로 제공하고 있음. 즉, 기본적으로 내장된 함수형 인터페이스를 사용하여 매번 같은 기능을 수행하는 함수형 인터페이스를 직접 만드는 번거로움을 줄여줌.

package codeStates;

public class LambdaExample {
    public static void main(String[] args) {
        SumFunction s = (n1, n2) -> n1 + n2;
        System.out.println(s.sum(2,3));

    }

    @FunctionalInterface
    interface SumFunction{
        int sum(int num1, int num2);
    }
}

 

 

 

❓메서드 레퍼런스

메서드 참조는 람다식에서 불필요한 매개변수를 제거할 때 주로 사용, 즉 람다식으로 더욱 간단해진 익명 객체를 더욱 더 간단하게 사용하고 싶은 개발자의 니즈가 반영된 산물. (클래스 이름 :: 메서드 이름) 메서드 참조도 람다식과 마찬가지로 인터페이스의 익명 구현 객체로 생성되므로 인터페이스의 추상 메서드가 어떤 매개변수를 가지고, 리턴 타입이 무엇이냐에 따라 달라짐.

정적 메소드, 인스턴스 메소드를 참조하는 경우)

//메서드 레퍼런스(참조) : 람다식에서 불필요한 매개변수를 제거할 때 주로 사용
//클래스 이름 :: 메서드 이름 (정적, 인스턴스 메서드를 참조할 수 있고, 생성자 참조도 가능)
IntBinaryOperator operator;

//정적 메소드
operator=Calculator::staticMethod;
System.out.println("정적 메서드 결과 : " + operator.applyAsInt(2, 3));//5

//인스턴스 메서드
Calculator c = new Calculator();
operator = c::instanceMethod;
System.out.println("인스턴스 메서드 결과 : " + operator.applyAsInt(2, 3));//6

생성자 참조하는 경우)

package codeStates.lambda;

import java.util.function.BiFunction;
import java.util.function.Function;

//메서드 레퍼런스 -> 생성자 참조
class Member{
    private String name;
    private String id;

    public Member(){
        System.out.println("Member() 실행");
    }

    public Member(String id){
        System.out.println("Member(String id) 실행");
        this.id=id;
    }

    public Member(String name, String id){
        System.out.println("Member(String name, String id) 실행");
        this.name=name;
        this.id=id;
    }
    public String getName(){
        return name;
    }
    public String getId(){
        return id;
    }

}
public class LambdaExample2 {
    public static void main(String[] args) throws Exception {
        /*
            생성자 참조 문법
            클래스 :: new

            Interface Function<T,R>
            T : type of input (arguments)
            R : tyep of result (return ~)

            Interface BiFunctioin<T,U,R>
            T : type of the first argument to the function
            U : type of the second argument to the function
            R : type of the result of the function
         */
        Function<String, Member> function1 = Member::new;
        Member member1 = function1.apply("kimcoding");//Member(String id) 실행

        BiFunction<String, String, Member> function2 = Member::new;
        Member member2 = function2.apply("kimcoding", "김코딩");//Member(String name, String id) 실행

    }

}

 

 

 

 

❓Stream이란?

스트림이란 배열, 컬렉션의 저장 요소를 하나씩 참조해서 람다식으로 처리할 수 있도록 해주는 반복자. 스트림을 사용하면 List, Set, Map, 배열 등 다양한 데이터 소스로부터 스트림을 만들 수 있고, 이를 표준화된 방법으로 다룰 수 있음. 

 

 

 

 

❓Stream의 핵심 특징, 왜 사용하는가?

기존의 for문이나 Iterator를 사용하는 경우, 코드가 길고 복잡해짐. 스트림을 사용하면 선언형 프로그래밍 방식으로 데이터를 처리할 수 있어 인간친화적이고 직관적으로 코드 작성이 가능함. 또, 기존 방식으로 데이터를 처리하는 경우에는 데이터 소스를 각기 다른 방식으로 다뤄야 하지만, 스트림을 사용하면 데이터 소스가 무엇이냐에 관계없이 같은 방식으로 데이터를 가공, 처리할 수 있음. 

 

 

 

 

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

package codeStates.stream;

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

//명령형 프로그래밍 vs 선언형 프로그래밍
public class DeclaritiveProgrammingExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 4, 5, 6, 8);

        //명령형 프로그래밍 : 직접 모든 요소를 순회하며 작업 수행
        int sum=0;
        for(int number:numbers){
            if(number > 4 && (number%2==0)) sum += number;
        }

        System.out.println("명령형 프로그래밍을 사용한 합계 : "+sum);

        //선언형 프로그래밍 : 내부가 어떻게 동작하는 지 몰라도 어떤 코드가 어떤 역할을 하는지 직관적으로 파악 가능
        System.out.println("선언형 프로그래밍을 사용한 합계 : " +
                        numbers.stream()
                        .filter(number->number>4 && (number%2==0))
                        .mapToInt(number->number).sum()
        );

    }
}

 

 

 

 

❓스트림의 특징

1. 스트림 처리 과정은 생성, 중간 연산, 최종 연산 세 단계의 파이프 라인으로 구성

2. 스트림은 원본 데이터 소스를 변경하지 않음 (read-only) -> 스트림은 그 원본이 되는 데이터 소스의 데이터들을 변경하지 않음. 오직 데이터를 읽어올 수 있고, 데이터에 대한 변경과 처리는 생성된 스트림 안에서만 수행됨.

3. 스트림은 일회용이다.(onetime-only) -> 스트림이 생성되고, 중간 연산을 거쳐 최종연산이 수행되고 난 후에는 스트림은 닫히고 재사용 불가.

4. 스트림은 내부 반복자이다. -> 스트림은 컬렉션 내부에 데이터 요소 처리 방법(람다식)을 주입시켜서 요소를 반복 처리.

 

 

 

 

❓스트림의 생성

- 배열 스트림 생성

- 컬렉션 스트림 생성

- 임의의 수 스트림 생성

 

 

 

 

❓배열 스트림 생성

package codeStates.stream;

import java.util.Arrays;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;

//배열 스트림 생성
public class ArraysStreamExample {
    public static void main(String[] args) {
        //문자열 배열 선언 및 할당
        String[] arr = new String[]{"김코딩", "이자바", "박해커"};

        //문자열 스트림 생성 -> 두 가지 방법 Arrays.stream(), Stream.of()
//        Stream<String> stream = Arrays.stream(arr);
        Stream<String> stream = Stream.of(arr);

        //출력
        stream.forEach(System.out::println);

        //Arrays 클래스에는 기본형 배열을 데이터 소스로 스트림을 생성하는 메서드도 있음
        //IntStream, DoubleStream, LongStream -> 숫자와 관련된 유용한 메서드들 정의되어 있음.
        double[] doubleArr = {1.0, 2.0, 3.2};
        DoubleStream doubleStream = Arrays.stream(doubleArr);
        double average = doubleStream.average().getAsDouble();


        //IntStream의 유용한 기능들
        //int 배열로 스트림 생성
        int[] intArr = {1, 2, 3, 4, 5, 6};
        IntStream intStream = Arrays.stream(intArr);

        //숫자와 관련된 경우 intStream을 사용하는 것을 권장
        System.out.println("sum="+intStream.sum());
//        System.out.println("average="+intStream.average()); -> sum() 메서드 호출 후 stream이 닫히기 때문에  에러 발생

    }
}

 

 

 

 

❓컬렉션 스트림 생성

package codeStates.stream;

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

//컬렉션 스트림 생성
/*
    컬렉션 최상위 클래스인 Collection에 정의된 stream() 메서드를 사용하여 스트림 생성 가능
 */
public class CollectionStreamExample {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        Stream<Integer> stream = list.stream();
        stream.forEach(System.out::print);

        System.out.println();

        Map<String, Integer> map=new HashMap<>();
        map.put("James", 12);
        map.put("Tomas", 10);
        map.put("Amy", 9);
        map.put("Sara", 8);
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        //오름차순
        entrySet.stream()
                .sorted(Map.Entry.comparingByValue())
                .forEach(e -> System.out.printf("key : " + e.getKey() + " value : " + e.getValue()+"\n"));
        //내림차순
        entrySet.stream()
                .sorted((a,b)-> b.getValue() - a.getValue())
                .forEach(e -> System.out.printf("key : " + e.getKey() + " value : " + e.getValue()+"\n"));
    }
}

 

 

 

 

❓임의의 수 스트림 생성

package codeStates.stream;

import java.util.Random;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;

//임의의 수 스트림 생성
public class RandomNumberStreamExample {
    public static void main(String[] args) {
        //무한으로 난수 생성 -> infinite stream
//        IntStream ints = new Random().ints();

        //1. limit으로 스트림의 사이즈를 전달해서 그 범위 제한 -> 생성할 수의 갯수를 5개로 제한
        IntStream ints = new Random().ints(5);
        //IntStream ints=new Ranodom().ints().limit(5);
        ints.forEach(System.out::println);

        System.out.println("-".repeat(60));

        DoubleStream doubles = new Random().doubles(10);//10개로 제한
        doubles.forEach(System.out::println);



        //2.특정 범위의 정수 : range(), rangeClose() -> 생성할 수의 값의 범위를 제한
        IntStream intStream1 = IntStream.rangeClosed(1, 10); //-> 끝번호가 포함되어 1~10까지의 숫자 출력
        IntStream intStream2 = IntStream.range(1, 10); // -> 끝번호 포함되지 않아 1~9까지 출력.
        intStream1.forEach(e-> System.out.print(e+" "));//1 2 3 4 5 6 7 8 9 10
        intStream2.forEach(e-> System.out.print(e+" "));//1 2 3 4 5 6 7 8 9

    }
}

 

 

 

 

❓스트림의 중간 연산

스트림의 중간 연산자의 결과는 스트림을 반환하기 때문에 여러 개의 연산자를 연결하여 원하는 데이터 처리 수행 가능

- 필터링

- 매핑

- 정렬

package codeStates.stream;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.IntStream;

//스트림의 중간 연산
public class StreamIntermediateOperationExample {
    public static void main(String[] args) {
        //1. distince : 중복 제거
        List<String> names = Arrays.asList("김코딩", "이자바", "김해커","김코딩","박해커");
        names.stream()
                .distinct()
                .forEach(element-> System.out.print(element+" "));//김코딩 이자바 김해커 박해커
        System.out.println("\n"+"-".repeat(60));

        //2. filter : 조건(람다식 Predicate)에 맞는 데이터들만 정제하여 더 작은 컬렉션 만들어냄
        names.stream()
                .filter(element -> element.startsWith("김"))
                .forEach(element -> System.out.print(element+" "));//김코딩 김해커 김코딩

        System.out.println("\n"+"-".repeat(60));


        names.stream()
                .distinct()
                .filter(element -> element.startsWith("김"))
                .forEach(element -> System.out.print(element+" "));//김코딩 김해커

        System.out.println("\n"+"-".repeat(60));

        //2. map : 원하는 필드만 추출하거나 특정 형태로 변환할 때 사용
        List<String> students = Arrays.asList("Amy", "James", "Sara");
        students.stream()
                .map(element -> element.toUpperCase())
                .forEach(System.out :: print); //AMYJAMESSARA

        System.out.println("\n"+"-".repeat(60));

        List<Integer> list = Arrays.asList(1, 2, 3);
        System.out.println(list.stream()
                .map(n->n*3)
                .mapToInt(e->e)
                .average().getAsDouble());

        System.out.println("-".repeat(60));

        //flatMap() : 중첩 구조를 제거하고 단일 컬렉션으로 만들어줌.
        String[][] namesArray = new String[][]{{"박해커", "이자바"}, {"김코딩", "나박사"}};
        //기존 방식
        Arrays.stream(namesArray)
                .map(e-> Arrays.stream(e))
                .forEach(name -> name.forEach(System.out::print));//박해커이자바김코딩나박사

        System.out.println("\n"+"-".repeat(60));

        //flatMap
        Arrays.stream(namesArray).
                flatMap(Arrays::stream)
                .forEach(System.out::print);//박해커이자바김코딩나박사

        System.out.println("\n"+"-".repeat(60));

        //3.sorted() : ()안에 Comparator라는 인터페이스에 정의된 static 메서드 or default 메서드를 사용하여 간편하게 정렬
        List<String> animals = Arrays.asList("Tiger", "Lion", "Monkey", "Duck");

        //인자값 없는 sort() 호출 -> 오름차순으로 정렬
        animals.stream().sorted().forEach(System.out::print);//DuckLionMonkeyTiger

        System.out.println("\n"+"-".repeat(60));

        //역순으로 정렬
        animals.stream().sorted(Comparator.reverseOrder()).forEach(System.out::print);//TigerMonkeyLionDuck

        System.out.println("\n"+"-".repeat(60));

        //문자열 길이순으로 정렬(오름차순)
        animals.stream().sorted((a,b)->a.length()-b.length()).forEach(System.out::print);//LionDuckTigerMonkey

        System.out.println("\n"+"-".repeat(60));

        //4.skip(int n) : n개의 숫자를 건너뛰고
        IntStream intStream1 = IntStream.rangeClosed(1, 10);
        intStream1.skip(5).forEach(System.out::print);//678910

        System.out.println("\n"+"-".repeat(60));


        //5.limit(int n) : n개의 숫자까지
        IntStream intStream2 = IntStream.rangeClosed(1, 10);
        intStream2.limit(5).forEach(System.out::print);//12345

        System.out.println("\n"+"-".repeat(60));


        //6.peek(action) : 요소들을 순회하며 특정 작업(action) 수행
        IntStream intStream3 = IntStream.of(1,2,3,4,5);
        int sum=intStream3.filter(e->e%2==0)
                .peek(System.out::print)
                .sum();
        System.out.println("합계 : "+sum);//24합게 : 6 -> 짝수만 필터링해서 합계 구하기




    }
}

 

 

 

 

❓스트림 최종 연산

- 기본 집계

- 매칭

- 요소 소모

- 요소 수집

-기타

package codeStates.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.OptionalDouble;
import java.util.stream.Collectors;

//스트림 최종 연산
public class StreamTerminalOperation {
    public static void main(String[] args) {
        //1.기본 집계
        int[] intArray = {1, 2, 3, 4, 5};

        //카운팅
        long count= Arrays.stream(intArray).count();
        System.out.println("count : " + count);

        //합계
        long sum = Arrays.stream(intArray).sum();
        System.out.println("sum : " + sum);

        //평균
        double average = Arrays.stream(intArray).average().getAsDouble();
        System.out.println("average : " + average);

        //평균 -> getAsDouble()은 최종 연산과는 관계 없다! 자료형을 변환해줄 뿐
        OptionalDouble average2 = Arrays.stream(intArray).average();
        System.out.println(average2);//OptionalDouble[3.0]
        double result = average2.getAsDouble();
        System.out.println("average2 : "+result);//average2 : 3.0


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

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

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

        System.out.println("-".repeat(60));

        //2.매칭 : 조건식 람다 Predicate를 매개변수로 넘겨 스트림의 각 데이터 요소들이 특정 조건을 만족하는지 여부를 boolean으로 리턴
        int[] intArray2 = {2, 4, 6};

        //allMatch()
        boolean isAllEven=Arrays.stream(intArray2).allMatch(e->e%2==0);
        System.out.println("요소 모두 2의 배수인가? " + isAllEven);//true

        //noneMatch()
        boolean isAllNotEven=Arrays.stream(intArray2).noneMatch(e->e%2==0);
        System.out.println("요소 모두 2의 배수가 아닌가? "+isAllNotEven);//false

        //anyMatch()
        boolean isAnyEven = Arrays.stream(intArray2).anyMatch(e -> e % 2 == 0);
        System.out.println("요소 중 하나라도 2의 배수가 있는가? "+isAnyEven);//true

        System.out.println("-".repeat(60));

        //3. reduce() : 스트림의 요소를 줄여나가면서 연산으 수행하고 최종 결과 반환
        int[] intArray3 = {1, 2, 3, 4, 5};

        //초기값이 없는 reduce()
        int sum2 = Arrays.stream(intArray3)
                .map(e -> e * 2)
                .reduce((a, b) -> a + b)
                .getAsInt();
        System.out.println("초기값이 없는 reduce() : " + sum2);

        //초기값이 있는 reduce()
        int sum3=Arrays.stream(intArray3)
                .map(e->e*2)
                .reduce(5, (a,b)->a+b);
        System.out.println("초기값이 있는 reduce() : " + sum3);

        System.out.println("-".repeat(60));


        //4.collect() : 스트림 요소들을 List, Set, Map 등 다른 타입의 결과로 수집하고 싶은 경우.
        List<Student> totalList = Arrays.asList(
                new Student("김코딩", 100, Student.Gender.Male),
                new Student("박해커", 90, Student.Gender.Male),
                new Student("이자바", 80, Student.Gender.Female),
                new Student("김자바", 100, Student.Gender.Male),
                new Student("박자바", 70, Student.Gender.Female)

        );

        //스트링 연산 결과를 Map으로 변환
        Map<String, Integer> maleMap = totalList.stream()
                .filter(s -> s.getGender() == Student.Gender.Male)
                .collect(Collectors.toMap(
                        student -> student.getName(),
                        student -> student.getScore()
                ));
        System.out.println(maleMap);//{김코딩=100, 김자바=100, 박해커=90}

        //스트링 연산 결과를 List로 변환
        List<String> femaleList=totalList.stream()
                .filter(s->s.getGender()==Student.Gender.Female)
                .map(e->e.toString())
                .collect(Collectors.toList());

        System.out.println(femaleList);//[이자바's score : 80 Gender : Female, 박자바's score : 70 Gender : Female]
    }
}

class Student{
    public enum Gender {Male, Female};
    private String name;
    private int score;
    private Gender gender;

    public Student(final String name, final int score, final Gender gender) {
        this.name = name;
        this.score = score;
        this.gender = gender;
    }

    public String getName() {
        return this.name;
    }

    public int getScore() {
        return this.score;
    }

    public Gender getGender() {
        return this.gender;
    }

    @Override
    public String toString() {
        return getName() + "'s score : " + getScore() + " Gender : " + getGender();
    }
}