[Java] 람다식

람다식

• 자바 8 이후 생긴 문법
• 리액트, 자바스크립트에서 사용
• 익명객체를 만드는 문법
• 함수적 인터페이스의 구현 객체를 생성하는 간소화 문법
• 함수적 인터페이스의 추상메소드를 클래스 없이 구현하는 방법
• () : 선언부. 변수 들어감
• 함수적 인터페이스 : 구현해야 하는 추상메소드가 단 하나만 존재하는 인터페이스를 의미
• 만약 함수적 인터페이스로 선언한 후 이미 람다식을 이용하여  구현 객체를 사용하고 있는 경우 추후 추상메소드 추가시 문법 오류가 발생할 수 있다. 이를 방지하기 위하여 어노테이션 @FunctionalInterface 을 사용하면 강력한 컴파일을 통하여 반드시 하나의 추상메도스만 갖는 함수적 인터페이스를 구현할 수 있다
• 인터페이스의 익명 구현 클래스 영역에서 생성자를 제외하고 클래스 구성요소들 구현 가능
  단, 추상메소드를 제외한 구성요소들은 중괄호 안에서만 사용 가능
• 매개변수가 하나만 존재할 때는 괄호를 생략할 수 있다
• 실행문이 하나이면 중괄호 생략가능
• 실행문이 return 한줄 밖에 없는 경우 중괄호와 return을 생략할 수 있다
• 람다식은 추상메소드의 정의부이기 때문에 매개변수의 타입이 이미 정해져있으므로 var 키워드를 사용하여 매개변수를 선언할 수 있다. (var : 변수 선언이라는 키워드)

 

 

1) 

@FunctionalInterface
public interface FunctionalService {
	void method1(int a, int b);
	//void method2(int a, int b);
}

 

public class Main1 {
	public static void main(String[] args) {
		//익명 객체를 활용하여 인터페이스의 익명 구현객체 대입하기
		FunctionalService fs = new FunctionalService() {
			//FunctionalService 인터페이스의 익명 구현 클래스 영역
			//생성자를 제외하고 클래스 구성요소들 구현 가능
			//단, 추상메소드를 제외한 구성요소들은 중괄호 안에서만 사용 가능
			public String field = "안녕";
			
			
			@Override
			public void method1(int a, int b) {
				System.out.println(field);
			}
		};
		
		fs.method1(0, 0);
		//fs.field = "java"; FunctionalService 인터페이스에 field가 없기 때문에 오류발생
		
		
		FunctionalService fs2 = (a,b) -> {
			System.out.println(a +", " + b);
		};
		
		fs2.method1(10, 5);
		
		
		fs2 = (a,b) -> {
			System.out.println(a + b);
		};
		
		fs2.method1(1, 2);
	}
}

안녕 10, 5 3

 

 

 

2)

@FunctionalInterface 
public interface Calculable {
	void calculate(int x, int y);
}

 

public class CalculableExample {
	public static void action(Calculable calculable) {
		int x = 10;
		int y = 4;
		calculable.calculate(x, y);
	}
	
	
	public static void main(String[] args) {
		/*
 		Calculable calculable = () -> {}; 
 		calculable.calculate();
		            ↓
		action(Calculable calculable);
		action(new Calculable());
		            ↓
		action(()->{});
        		    ↓
		*/
		action((x,y)->{
			int result = x + y;
			System.out.println("result:" + result);
		});
		
		
		action((x,y)->{
			int result = x - y;
			System.out.println("result:" + result);
		});
	}
}

result:14 result:6

 

 

 

매개변수가 없는 람다식

• 매개변수가 1개만 존재할 경우 괄호 생략 가능
• 괄호 생략시에는 매개변수의 타입은 생략한다
• 매개변수가 없는 추상메소드는 괄호를 생략할 수 없다

 

 

매개변수가 1개만 존재할 경우

@FunctionalInterface
public interface FunctionalService3 {
	void method(int a);
}

 

//FunctionalService3 fs3_1 = (a) ->{
FunctionalService3 fs3_1 = a ->{
    System.out.println(a);
};

fs3_1.method(10);

10

 

 

 

매개변수가 없을 경우

@FunctionalInterface
public interface FunctionalService2 {
	void method();
}

 

FunctionalService2 fs2_1 = ()->{
    System.out.println("함수적 인터페이스 실행");
};

fs2_1.method();

함수적 인터페이스 실행

 

 

 

var 키워드를 사용하여 매개변수를 선언할 수 있다

fs2 = (var a, var b)-> {

};

 

 

 

매개변수가 2개인 경우, 매개변수가 1개인 경우

@FunctionalInterface
public interface Workable {
	void work(String name,String job);
}

 

@FunctionalInterface
public interface Speakable {
	void speak(String content);
}

 

public class Person {
	public void action1(Workable w) {
		w.work("홍길동", "프로그래밍");
	}
	
	public void action2(Speakable s) {
		s.speak("안녕하세요");
	}
	
	
	public static void main(String[] args) {
		Person p = new Person();
		
		//매개변수가 두 개일 경우
		p.action1((name,job)->{
			System.out.print(name+"이 ");
			System.out.println(job+"을 합니다.");
		});
		
		p.action1((name,job)->System.out.println(name + "이 " + job +"을 하지 않습니다."));
		
		//매개변수가 한 개일 경우
		p.action2(word -> {
			System.out.print("\"" + word + "\"");
			System.out.println("라고 말합니다");
		});
		
		p.action2(word -> System.out.println("\"" + word + "\"라고 외칩니다"));
	}
}

홍길동이 프로그래밍을 합니다. 홍길동이 프로그래밍을 하지 않습니다. "안녕하세요"라고 말합니다 "안녕하세요"라고 외칩니다

 

 

 

리턴값이 존재하는 람다식

• 리턴값이 존재하는 함수적 인터페이스의 람다식은 중괄호 안쪽에서 return 키워드를 사용하여 값을 반환할 수 있다

 

@FunctionalInterface
public interface FunctionalService4 {
	int method(String a);
}

 

FunctionalService4 fs4 = a->{
    return Integer.parseInt(a);
};

System.out.println(fs4.method("2003"));

2003

 

 

 

FunctionalService4의 구현객체를 람다식을 통하여 정의합니다
 이때 fs4.method("10"); 의 결과는 2입니다
 fs4.method("13"); 의 결과는 2입니다
 fs4.method("15"); 의 결과는 3입니다
 fs4.method("20"); 의 결과는 4입니다

fs4 = a->{
    return Integer.parseInt(a)/5;
};

System.out.println(fs4.method("10"));
System.out.println(fs4.method("13"));
System.out.println(fs4.method("15"));
System.out.println(fs4.method("20"));

2 2 3 4

 

 

실행문이 return 한줄 밖에 없는 경우 중괄호와 return을 생략할 수 있다

fs4 = a -> Integer.parseInt(a)/5;
		
System.out.println(fs4.method("10"));
System.out.println(fs4.method("13"));
System.out.println(fs4.method("15"));
System.out.println(fs4.method("20"));

2 2 3 4

 

 

람다식 실행문에 메소드 사용

public static int doubleMethod(String s) {
    return Integer.parseInt(s)*2;
}

fs4 = a -> doubleMethod(a);

System.out.println(fs4.method("10"));
System.out.println(fs4.method("13"));
System.out.println(fs4.method("15"));
System.out.println(fs4.method("20"));

20 26 30 40

 

 

 

실행문이 2개 이상일 경우

리턴문이 하나만 있을 경우(연산식)

리턴문이 하나만 있을 경우(메소드 호출)

@FunctionalInterface 
public interface Calc {
	double calc(double x, double y);
}

 

public class Person2 {
	
	public void action(Calc c) {
		double result = c.calc(10, 4);
		System.out.println("결과:" + result);
	}
	
	public static double sum(double x, double y) {
		return x + y;
	}
	
	public static void main(String[] args) {
		Person2 p2 = new Person2();
		
		//실행문이 2개 이상일 경우
		p2.action((x,y)->{
			double result = x + y;
			return result;
		});
		
		//리턴문이 하나만 있을 경우(연산식)
		/*
		p2.action((x,y)->{
			return x + y;
		});
		*/
		p2.action((x,y)->x+y);
		
		//리턴문이 하나만 있을 경우(메소드 호출)
		/*
		p2.action((x,y)->{
			return sum(x,y);
		});
		*/
		p2.action((x,y)->sum(x,y));
	}
}

결과:14.0 결과:14.0 결과:14.0