Study/Java

[TIL] λžŒλ‹€

hong- 2022. 5. 20. 21:58

πŸ‘ŒπŸ» λžŒλ‹€ Lambda

 ( λ§€κ°œλ³€μˆ˜ ) -> { μ‹€ν–‰μ½”λ“œ }

  - 읡λͺ… ν•¨μˆ˜λ₯Ό μƒμ„±ν•˜κΈ° μœ„ν•œ μ‹μœΌλ‘œ ν•¨μˆ˜ μ§€ν–₯ 언어에 κ°€κΉŒμ›€

  - μˆ˜ν•™μ—μ„œ μ‚¬μš©ν•˜λŠ” ν•¨μˆ˜λ₯Ό 보닀 λ‹¨μˆœν•˜κ²Œ ν‘œν˜„ν•˜λŠ” 방법

  - λ§€κ°œλ³€μˆ˜λ₯Ό κ°€μ§„ μ½”λ“œ λΈ”λ‘μ΄μ§€λ§Œ λŸ°νƒ€μž„μ— 읡λͺ… κ΅¬ν˜„ 객체 생성

 

  πŸ’‘ μžλ°”μ—μ„œ λžŒλ‹€μ‹μ„ μ‚¬μš©ν•˜λŠ” 이유 ?

    : λžŒλ‹€μ‹μ„ μ‚¬μš©ν•˜λ©΄ μžλ°” μ½”λ“œκ°€ 맀우 κ°„κ²°ν•΄μ§€κ³  

      μ»¬λ ‰μ…˜μ˜ μš”μ†Œλ₯Ό ν•„ν„°λ§ν•˜κ±°λ‚˜ λ§€ν•‘ν•΄μ„œ μ›ν•˜λŠ” κ²°κ³Ό 집계 쉬움


πŸ“λžŒλ‹€μ‹ κΈ°λ³Έ 문법

 1️⃣  κΈ°λ³Έμž‘μ„±

(νƒ€μž… λ§€κ°œλ³€μˆ˜) -> { ... }

 - λ§€κ°œλ³€μˆ˜λ₯Ό μ΄μš©ν•˜μ—¬ μ€‘κ΄„ν˜Έ 싀행블둝을 μ‹€ν–‰ν•œλ‹€λŠ” 의미

 2️⃣  λ§€κ°œλ³€μˆ˜κ°€ 1개 일 λ•Œ ( ) μƒλž΅ κ°€λŠ₯

λ§€κ°œλ³€μˆ˜ -> { ... }

- λ§€κ°œλ³€μˆ˜κ°€ μ—†λ‹€λ©΄ κ΄„ν˜Έ μƒλž΅ν•˜λ©΄ μ•ˆ 됨

- ν•˜λ‚˜μ˜ μ‹€ν–‰λ¬Έλ§Œ μžˆλ‹€λ©΄ μ€‘κ΄„ν˜Έλ„ μƒλž΅ κ°€λŠ₯

3️⃣  λ§€κ°œλ³€μˆ˜κ°€ 2개 이상이고 λ¦¬ν„΄λ¬Έλ§Œ μ‘΄μž¬ν•˜λ©΄ return μƒλž΅ κ°€λŠ₯

(λ§€κ°œλ³€μˆ˜ 1, λ§€κ°œλ³€μˆ˜ 2) -> 리턴값 ;

 4️⃣  λ§€κ°œλ³€μˆ˜κ°€ 2개 이상이고 싀행문을 μ‹€ν–‰ν•˜κ³  κ²°κ³Όκ°’ 리턴

(λ§€κ°œλ³€μˆ˜ 1, λ§€κ°œλ³€μˆ˜ 2) -> { ... };

✌🏻 ν•¨μˆ˜ν˜• μΈν„°νŽ˜μ΄μŠ€

  : 단 ν•˜λ‚˜μ˜ 좔상 λ©”μ„œλ“œλ§Œμ„ ν¬ν•¨ν•˜λŠ” μΈν„°νŽ˜μ΄μŠ€

 

 - μžλ°”μ—μ„œ λ©”μ„œλ“œ μ‚¬μš© ? 클래슀 객체 생성 ν›„ μƒμ„±ν•œ κ°μ²΄μ—μ„œ λ©”μ„œλ“œ 호좜

 - 곡톡적인 κΈ°λŠ₯ μ‚¬μš© ? ν΄λž˜μŠ€λ§ˆλ‹€ λ©”μ„œλ“œ μ •μ˜

   πŸ‘‰πŸ» 이λ₯Ό ν•΄κ²°ν•˜κΈ° μœ„ν•΄ μΈν„°νŽ˜μ΄μŠ€ 문법을 ν™œμš©ν•œ 'λžŒλ‹€μ‹' λ“±μž₯

 

πŸ“ νƒ€κ²Ÿ νƒ€μž…κ³Ό ν•¨μˆ˜ν˜• μΈν„°νŽ˜μ΄μŠ€

 - ν•˜λ‚˜μ˜ 좔상 λ©”μ„œλ“œκ°€ μ„ μ–Έλœ μΈν„°νŽ˜μ΄μŠ€(=ν•¨μˆ˜ν˜• μΈν„°νŽ˜μ΄μŠ€)만 λžŒλ‹€μ‹μ˜ νƒ€κ²Ÿ νƒ€μž…μ΄ 될 수 있음

 - @FunctionalInterface : μ»΄νŒŒμΌλŸ¬κ°€ 좔상 λ©”μ„œλ“œκ°€ 두 개 이상이 λ˜μ§€ μ•Šλ„λ‘ μ²΄ν¬ν•΄μ£ΌλŠ” μ• λ„ˆν…Œμ΄μ…˜


 β–ͺ️ λ§€κ°œλ³€μˆ˜μ™€ 리턴 값이 μ—†λŠ” λžŒλ‹€μ‹

@FunctionalInterface
public interface LambdaTest {
	public void check();
 }
package Fri;

import static Fri.LambdaTest.*;

public class LambdaTestExample {
    public static void main(String[] args) throws Exception {
        LambdaTest test;
        test = () -> {
            String str = "First";
            System.out.println(str);
        };
        test.check();

        test = () -> {
            System.out.println("Second");
        };
        test.check();
    }
}

  - test.check( )둜 ν˜ΈμΆœν•΄μ£Όμ–΄μ•Ό λžŒλ‹€μ‹μ˜ μ€‘κ΄„ν˜Έ μ‹€ν–‰μ‹œν‚΄


 β–ͺ️ λ§€κ°œλ³€μˆ˜κ°€ μžˆλŠ” λžŒλ‹€μ‹

package Fri;

public interface LambdaTest2 {
    public void okay(int i);
}
package Fri;

public class LambdaEx {
    public static void main(String[] args) {
        LambdaTest2 test2;
        test2 = (i) -> {
            int num = i * 10;
            System.out.println(num);
        };
        test2.okay(3);

        test2 = (i) -> System.out.println(i*10);
        test2.okay(5);
    }
}

 β–ͺ️ λ¦¬ν„΄ 값이 μžˆλŠ” λžŒλ‹€μ‹

package Fri;

public interface LambdaTest3 {
    public int calcu(int a, int b);
}
package Fri;

public class LambdaEx3 {
    public static void main(String[] args) {
        LambdaTest3 test3;
        test3 = (a, b) -> {
            int output = a + b;
            return output;
        };
        int output = test3.calcu(4, 5);
        System.out.println(output);

        test3 = (a, b) -> { return a+b; };
        int output2 = test3.calcu(2, 5);
        System.out.println(output2);

        test3 = (a, b) -> a+b;
        int output3 = test3.calcu(3,5);
        System.out.println(output3);

        test3 = (a, b) -> sum(a,b);
        int output4= test3.calcu(1, 3);
        System.out.println(output4);
    }
    public static int sum(int a , int b){
        return a + b;
    }
}

✌🏻 λ©”μ„œλ“œ 레퍼런슀

  - λžŒλ‹€μ‹μ„ 더 κ°„λ‹¨ν•˜κ²Œ ν‘œν˜„ν•˜λŠ” 방법

  - λžŒλ‹€μ‹μ—μ„œ λΆˆν•„μš”ν•œ λ§€κ°œλ³€μˆ˜ 제거

  - λžŒλ‹€μ‹μ€ λ©”μ„œλ“œλ₯Ό μ‚¬μš©ν•˜λΌκ³  κ°€λ₯΄ν‚€λŠ” 방식이라면 λ©”μ„œλ“œ λ ˆνΌλŸ°μŠ€λŠ” 직접 μ°Έμ‘°ν•˜λŠ” 방식 (가독성 up)

(1) 정적 λ©”μ†Œλ“œ μ°Έμ‘°
  클래슀 :: λ©”μ„œλ“œ ;
  
(2) μΈμŠ€ν„΄μŠ€ λ©”μ„œλ“œ μ°Έμ‘°
  μ°Έμ‘°λ³€μˆ˜ :: λ©”μ„œλ“œ ;

 - 일반적으둜 클래슀λͺ…κ³Ό λ©”μ„œλ“œλͺ… 사이에 :: λ₯Ό λ„£μ–΄ μ‚¬μš©

(Apple apple) -> apple.madeJam()
Apple ::madeJam

(str, x) -> str.happy
String::happy

(String str) -> System.out.println(str)
System.out::println

(String str) -> happy.birth(str)
happy::birth

 - μΈν„°νŽ˜μ΄μŠ€μ˜ 좔상 λ©”μ„œλ“œμ˜ λ§€κ°œλ³€μˆ˜ 및 리턴 νƒ€μž…μ— 따라 달라짐

 - μΈμŠ€ν„΄μŠ€ λ©”μ„œλ“œλŠ” λ¨Όμ € 객체λ₯Ό μƒμ„±ν•œ ν›„ μ°Έμ‘°λ³€μˆ˜ :: λ©”μ„œλ“œ


πŸ“ λ§€κ°œλ³€μˆ˜μ˜ λ©”μ„œλ“œ 레퍼런슀

 - λ©”μ„œλ“œλŠ” λžŒλ‹€μ‹ μ™ΈλΆ€μ˜ 클래슀 멀버일 수 있고 λžŒλ‹€μ‹ λ‚΄λΆ€μ˜ λ§€κ°œλ³€μˆ˜μ˜ 멀버 쀑 ν•˜λ‚˜


πŸ“ μƒμ„±μž μ°Έμ‘°

 - μƒμ„±μžλ₯Ό μ°Έμ‘°ν•œλ‹€λŠ” 것은 객체 생성을 의미

 - μƒμ„±μžκ°€ μ˜€λ²„λ‘œλ”©λ˜μ–΄ μ—¬λŸ¬ 개 μžˆμ„ 경우 λ™μΌν•œ λ§€κ°œλ³€μˆ˜ νƒ€μž…κ³Ό 개수λ₯Ό κ°–λŠ” μƒμ„±μžλ₯Ό μ°Ύμ•„ μ‹€ν–‰

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

클래슀 :: new
[ λžŒλ‹€μ‹ ]
Wash<Fruit> Wash1 = () -> new Fruit();
Fruit fruit1 = Wash1.get();

[ λ©”μ†Œλ“œ 레퍼런슀 ]
Wash<Fruit> Wash2 = Fruit::new;
Fruit fruit2 = Wash2.get();