Lambda Expression

chaming·2021년 12월 12일

JAVA

목록 보기

4/4

Epilogue🙎‍♀️
나중에 공부해야지 하고 미루고 그냥 구글링만해서 그 때 그 때 사용했었는데,늦었지만 지금이라도 제대로 알고 사용하자 생각이 들어 정리를 시작해봅니다!!

람다식은 익명함수를 생성하기 위한 식으로 객체지향언어보다는 함수지향언어에 가깝다. (java8부터 지원)

코드가 매우 간결해지고, 컬렉션의 요소를 필터링하거나 매핑하여 원하는 결과를 얻을 수 있다는 장점

람다식의 형태는 매개변수를 가진 코드 블록이지만, 런타임 시에는 익명 구현 객체를 생성한다.

람다식 -> 매개변수를 가진 코드 블록 -> 익명 구현 객체

Runnable runnable = new Runnable() {	// 익명 구현 객체
  public void method();  
};

// 람다식 표현
Runnable runnable = (타입 매개변수, ...) -> {실행문; ...};

타겟타입과 함수적 인터페이스

함수적 인터페이스(@FunctionalInteface)

모든 인터페이스를 람다식의 타켓타입으로 사용할 수 없고, 람다식이 하나의 메소드를 정의하기 때문에 두 개 이상의 추상 메소드가 선언된 인터페이스는 람다식을 이용해서 구현 객체를 생성할 수 없다.

하나의 추상 메소드가 선언 된 인터페이스만이 람다식의 타겟타입이 될 수 있다. = 함수적 인터페이스

이것을 가능하게 해주는 어노테이션이 @FunctionalInterface이다.

매개변수와 리턴값별 람다식표현

람다식 표현을 위한 MyFunctionalInterface Class

@FunctionalInterface
public Interface MyFunctionalInterface{
    // (※주의) 메소드는 무조건 하나만 선언이 가능하나, 설명을 위해 여러개를 선언한 것임
    public void method();				// 1.매개변수X , 리턴값X
    public void method(int a);			// 2.매개변수O , 리턴값X
    public int method(int a, int b);	// 3.매개변수O , 리턴값O
}

실행문

public class MyFunctionalInterfaceExample{
    public static void main(String[] args){
        // 1.매개변수X , 리턴값X
        MyFunctionalInterface fi = () -> System.out.println("test");
        fi.method();		// test
        
        // 2.매개변수O , 리턴값X
        MyFunctionalInterface fi2 = (a) -> System.out.println(a+2);
        fi2.method(5);		// 7
        
        // 3.매개변수O , 리턴값O
        MyFunctionalInterface fi3 = (a, b) -> {return a+b};
        fi2.method(fi3.method(5,7));		// 12
    }
}

클래스 멤버와 로컬 변수 사용

람다식의 실행 블록에는 클래스의 멤버 및 로컬 변수를 사용할 수 있다.

클래스의 멤버는 제약 사항 없이 사용 가능하지만, 로컬 변수는 제약사항이 따른다.

❗this 키워드 사용시 주의 필요

일반적인 익명 객체 내부에서의 this는 익명 객체의 참조
람다식에서의 this는 람다식을 실행한 객체의 참조이다.

public class UsingThis {
    public int outterField = 10;

    class Inner{
        int innerField = 20;
        void method(){
            MyFunctionalInterface fi = () -> {
                
                System.out.println("outterField :: " + outterField);
                // 바깥객체의 참고를 얻기 위해서는 클래스명.this
                System.out.println("outterField :: " + UsingThis.this.outterField);

                System.out.println("innerField :: " + innerField);
                // 람다식 내부에서의 this는 중첩객체인 Inner를 참조
                System.out.println("innerField :: " + this.innerField);
            };
            fi.method();
        }
    }

    public static void main(String... args){
        UsingThis usingThis = new UsingThis();
        UsingThis.Inner inner = usingThis.new Inner();
        inner.method();
    }
}

❗로컬 변수 사용

람다식에서 바깥 클래스의 필드나 메소드는 제한 없이 사용할 수 있으나, 메소드의 매개변수 또는 로컬변수를 사용하면 이 두 변수는 final특성을 가져야한다.
매개변수 또는 로컬변수를 읽는것은 허용하지만, 람다식의 내부 또는 외부에서 변경은 불가능하다.

public class UsingLocalVariable {
    void method(int arg){   // arg는 final특성을 가짐
        int localVar = 40;  // localVar는 final의 특성을 가짐

//        arg = 31;         // final 특성때문에 수정 불가, 컴파일 오류 발생
//        localVar = 30;    // final 특성때문에 수정 불가, 컴파일 오류 발생

        // lambda
        MyFunctionalInterface fi = () -> {
            System.out.println("arg : " + arg);
            System.out.println("localVar : " + localVar);
        };
        fi.method();
    }

    public static void main(String... args){
        UsingLocalVariable usingLocalVariable = new UsingLocalVariable();
        usingLocalVariable.method(50);
        // 50
        // 40
    }
}

표준 API의 함수적 인터페이스

종류	추상메소드 특징	메소드
Consumer	매개값O , 리턴값X	accept()
Supplier	매개값X, 리턴값O	getXXX()
Function	매개값O, 리턴값O 매개값을 리턴값으로 매핑(타입 변환)	applyXXX()
Operator	매개값O, 리턴값O 매개값을 연산하고 결과를 리턴	applyXXX()
Perdicate	매개값O, 리턴값 boolean	testXXX()

✅Consumer : 리턴값이 없는 accept() 메소드를 가짐

public class ConsumerExample {
    public static void main(String[] args){
        // 객체 t를 받아 소비
        Consumer<String> consumer = t-> System.out.println("test "+t);
        consumer.accept("java");

        // 객체 x와 y를 받아 소비
        BiConsumer<String, String> biConsumer = (x,y) ->System.out.println(x+ "::"+ y);
        biConsumer.accept("hello", "java");

        // double값을 받아 소비
        DoubleConsumer doubleConsumer = t -> System.out.println("java" + t);
        doubleConsumer.accept(0.8);

        // 객체a와 int b값을 받아 소비 accept(T t, int value)
        ObjIntConsumer<String> objIntConsumer = (a, b) -> System.out.println(a + b);
        objIntConsumer.accept("hello", 8);
    }
}

✅Supplier : 매개변수가 없고 리턴값이 있는 getXXX() 메소드를 가짐

ex) Supplier : T객체를 리턴

BooleanSupplier : boolean getAsBoolean()

public class SupplierExample {
    public static void main(String[] args){
        // 매개변수는 없고, int값을 리턴
        IntSupplier intSupplier = () ->{
            int num = (int)(Math.random() * 6) +1;
            return num;
        };
        System.out.println("주사위 눈의 수 : "+intSupplier.getAsInt());
    }
}

✅Function: 매개값이 있고 리턴값이 있는 applyXXX() 메소드를 가짐

(참고) Student Class : name(String) , englishScore(int), mathScore(int) 변수 가짐

public class FunctionExample1 {
    private static List<Student> list = Arrays.asList(
            new Student("차", 100,100),
            new Student("김", 95 , 80)
    );

    // Function<T,R> : 객체T를 객체R로 매핑
    public static void printString(Function<Student, String> function){
        for(Student student : list){
            // 람다식 실행 : R apply(T)
            System.out.print(function.apply(student) + " ");
        }
        System.out.println();
    }
    
	// ToIntFunction<T t> : 객체 T를 int로 매핑
    public static void printInt(ToIntFunction<Student> function){
        for(Student student : list){
            // 람다식 실행 : int applyeAsInt(T t)
            System.out.print(function.applyAsInt(student)+ " ");
        }
        System.out.println();
    }

    public static void main(String... args){
        System.out.println("학생 이름");
        printString(t -> t.getName());

        System.out.println("영어 점수");
        printInt( t -> t.getEnglishScore());

        System.out.println("수학 점수");
        printInt(t -> t.getMathScore());
    }
}

✅Operator : 매개값이 있고 리턴값이 있는 applyXXX() 메소드를 가짐

Function과의 차이점은 매개값을 리턴하는 역할보다는 매개값을 이용해 연산수행 후 동일타입으로 반환해준다.

public class OperatorExample {
    private static int[] scores = {92, 85, 86};

    // IntBianryOperator : 두 개의 int 연산
    public static int maxOrMin(IntBinaryOperator operator){
        int result = scores[0];
        for(int score: scores){
            // 람다식 실행 : int applyAsInt(int)
            result = operator.applyAsInt(result, score);
        }
        return result;
    }

    public static void main(String... args){
        int max = maxOrMin(
                (a,b) -> {
                    if(a >= b) return a;
                    else return b;
                }
        );
        System.out.println("최대값 : "+max);

        int min = maxOrMin(
                (a,b) -> {
                    if(a <= b) return a;
                    else return b;
                }
        );
        System.out.println("최솟값 : "+min);
    }
}

✅Predicate : 매개값이 있고 boolean 리턴값이 있는 testXXX() 메소드를 가짐

public class PredicateExample {
    private static List<Student> list = Arrays.asList(
            new Student("차차차", "여자", 90),
            new Student("Lee", "여자", 77),
            new Student("김김김","남자", 80),
            new Student("정정정","남자", 60)
    );
    
    // Predicate<T> : 객체 T를 조사
    public static double avg(Predicate<Student> predicate){
        int count = 0 ;
        int sum = 0;
        for(Student student : list){
            // boolean test(T t)
            if(predicate.test(student)){
                count++;
                sum += student.getMathScore();
            }
        }
        return (double) sum / count;
    }
    
    // 남자, 여자 평균 점수 구하기
    public static void main(String... args){
        double maleAvg = avg(t-> t.getSex().equals("남자"));
         System.out.println("남자 평균 점수 : "+maleAvg);

        double femaleAvg = avg(t-> t.getSex().equals("여자"));
         System.out.println("여자 평균 점수 : "+femaleAvg);
     }
}

andThen()과 compose() 디폴트 메소드

디폴트 및 정적메소드는 추상 메소드가 아니기 때문에 함수적 인터페이스에 선언되어도 함수적 인터페이스의 성질을 잃지 않는다. java.util.function패키지의 함수적 인터페이스는 하나 이상의 디폴트 및 정적메소드를 가진다.

인터페이스AB = 인터페이스A.andThen(인터페이스B);

최종결과 = 인터페이스AB.method();

✅andThen()

인터페이스AB의 method()를 호출하면 우선 인터페이스A부터 처리하고 결과를 인터페이스B의 매개값으로 제공.

인터페이스B는 제공받은 매개값을 가지고 처리한 후 최종 결과를 리턴.

ex) Consumer, Functon, Operator함수 디폴트메소드 제공

✅compose()

인터페이스AB의 method()를 호출하면 우선 인터페이스B부터 처리하고 결과를 인터페이스A의 매개값으로 제공

인터페이스A는 제공받은 매개값을 가지고 처리한 후 최종 결과를 리턴

예시) Function의 순차적 연결

public class FunctionAndThenComposeExample {
    public static void main(String[] args){
        Function<Member, Address> functionA;
        Function<Address, String> functionB;
        Function<Member, String> functionAB;
        String city;

        functionA = (m) -> m.getAddress();
        functionB = (m) -> m.getCity();
        
        // andThen() : 인터페이스A부터 처리한 뒤 그 결과를 인터페이스B가 처리한 후 최종 결과 리턴
        functionAB = functionA.andThen(functionB);
        city = functionAB.apply(
                new Member("홍길동", "gil", new Address("한국","서울"))
        );
        System.out.println("거주 도시 : "+city);

        // compose() : 인터페이스B부터 처리한 뒤 그 결과를 인터페이스A가 처리한 후 최종 결과 리턴
        functionAB = functionB.compose(functionA);
        city = functionAB.apply(
                new Member("홍길동", "gil", new Address("한국","서울"))
        );
        System.out.println("거주 도시 : "+city);
    }
}

and(), or(), negate() 디폴트 메소드와 isEqual() 정적 메소드

and() : 두 Predicate가 모두 true를 리턴하면 최종적으로 true 리턴

or() : 두 Predicate 중 하나만 true를 리턴하면 최종적으로 true 리턴

negate() : 원래 Predicate의 결과가 true면 false를 리턴, false면 true를 리턴

// 2의 배수
IntPredicate predicateA = a -> a % 2 == 0;

// 3의 배수
 IntPredicate predicateB = b -> b % 3 == 0;

 IntPredicate predicateAB;
 boolean result;

 // and()
 predicateAB = predicateA.and(predicateB);
 result = predicateAB.test(9);
 System.out.println("9는 2와 3의 배수입니까? : "+result);

 // or()
 predicateAB = predicateA.or(predicateB);
 result = predicateAB.test(9);
 System.out.println("9는 2 또는 3의 배수입니까? : "+result);

 // negate()
 predicateAB = predicateA.negate();
 result = predicateAB.test(9);
 System.out.println("9는 홀수입니까? : "+result);

 // isEquals()
 Predicate<String> predicate;

 predicate = Predicate.isEqual("JAVA8");
 System.out.println("JAVA8, null  :" +predicate.test(null));

 predicate = Predicate.isEqual(null);
 System.out.println("null, null  :" +predicate.test(null));

minBy(), maxBy() 정적메소드

o1과 o2를 비교하여 o1이 작으면 음수를, o1과 o2가 동일하면 0을 , o1이 크면 양수를 리턴하는 compare()

BinaryOperator<Fruit> binaryOperator;
Fruit fruit;

// compare()
// (o1, o2) -> {return o1> o2 ? (+) : (-)
binaryOperator = BinaryOperator.minBy((o1, o2) -> Integer.compare(o1.price, o2.price));
fruit = binaryOperator.apply(new Fruit("딸기", 2000), new Fruit("사과", 6000));
System.out.println("싼 과일 : "+fruit.name);

binaryOperator = BinaryOperator.maxBy((o1, o2) -> Integer.compare(o1.price, o2.price));
fruit = binaryOperator.apply(new Fruit("딸기", 2000), new Fruit("사과", 6000));
System.out.println("비싼 과일 : "+fruit.name);

메소드 참조

// 기존 메소드 단순호출
(left, right) -> Math.max(left, rigth);
// 불필요한 매개변수를 제거하여 메소드 참조
(left, right) -> Math::max;

✅ 정적메소드와 인스턴스 메소드 참조

정적메소드 참조 > 클래스 :: 메소드 ex)Calculator :: staticMethod;

인스턴스 메소드 참조 > 참조변수 :: 메소드 ex) calculator :: instanceMethod;

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

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

IntBinaryOperator operator;

// 정적메소드 호출
operator = (x,y) -> Calculator.staticMethod(x,y);
System.out.println(operator.applyAsInt(5,7));
// 정적메소드 참조
operator = Calculator :: staticMethod;
System.out.println(operator.applyAsInt(1,2));

// 인스턴스 메소드 호출
Calculator calculator = new Calculator();
operator = (x,y) -> calculator.instanceMethod(x, y);
System.out.println(operator.applyAsInt(5,7));
// 인스턴스 메소드 참조
operator = calculator ::instanceMethod;
System.out.println(operator.applyAsInt(1,3));

✅ 생성자 참조

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

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

// void main 호출
Function<String, Member> function1 = Member :: new;
Member member1 = function1.apply("angel1");

BiFunction<String, String, Member> function2 = Member :: new;
Member member2 = function2.apply("name", "angel2");

※ [이것이 자바다 신용권Java 프로그래밍 정복2] 해당 책을 참고하며 정리한 내용입니다.

chaming

Java Web Developer😊

이전 포스트