[JAVA] 람다 lambda

1. 람다(lambda)란?

- "Functional Interface"라고 부름.

- 추상메소드 1개만 존재하는 인터페이스

 

 

이해를 위해 인터페이스를 보기 전에 클래스로 먼저 접근하였다.

인터페이스의 구현(implements)과 클래스 상속(extends)을 같은 원리로 이해할 수 있기 때문이다.

 

*lambda의 활용법만 보려면 앞의 단계 건너뛰고 3-2를 확인

 

 

 

2. 할당할 때, 클래스 상속받기

1. 객체를 선언해서 사용

public class LambdaTest {
	//생성자
	public LambdaTest() {
		//재정의한 객체 생성 후, 사용
		t.func();
	}
	
	//새로운 클래스
	class Test{
		void func() {
			System.out.println("Testfunc");
		}
	}
	
	//Test를 상속 받아서 재정의
	Test t = new Test() {
		void func() {
			System.out.println("subTestfunc");
		}
	};
	
	public static void main(String[] args) {
		new LambdaTest();
	}
}

 

 

2. 바로 객체를 만들어서 사용

public class LambdaTest {
	//생성자
	public LambdaTest() {
		//new Test 뒤에 중괄호{}가 있다. = Test를 상속받아 쓰곘다.
		new Test() {
			//재정의
			void func() {
				System.out.println("subTestfunc2");
			}
		}.func();
	}
	
	//새로운 클래스
	class Test{
		void func() {
			System.out.println("Testfunc");
		}
	}
	
	public static void main(String[] args) {
		new LambdaTest();
	}
}

 

 

 

3. 할당할 때, 인터페이스 구현하기

1. 추상 메서드가 다수일 때

//인터페이스
interface Inter{
	void f1();
	void f2();
}

public class LambdaTest2 {
	public LambdaTest2() {
		print(impl);//1
		print(impl2);//2
		
		//3.바로 구현하여 사용, 이름X
		//재정의해서 다르게 사용 가능
		print(new Inter() {
			@Override
			public void f1() {System.out.println("다른 작업");}
			@Override
			public void f2() {}
		});
	}
	
	//1. 구현 클래스 만들어서 사용
	Inter impl = new InterImpl();
	class InterImpl implements Inter{
		@Override
		public void f1() { System.out.println("impl1_f1");}
		@Override
		public void f2() { System.out.println("impl1_f2");}
	}
	
	//2. 바로 구현하여 사용, 이름 O
	Inter impl2 = new Inter() {
		@Override
		public void f1() {System.out.println("impl2_f1");}
		@Override
		public void f2() {System.out.println("impl2_f2");}
	};
	
	void print(Inter inter) { inter.f1();}

	public static void main(String[] args) {
		new LambdaTest2();
	}

}

 

2. 추상 메서드가 1개일 때(=Lambda)

1) 매개변수와 반환값이 있을 때

interface Inter{
	int f1(int n);
}

public class LambdaTest3 {
	public LambdaTest3() {
		print(inter1);
		print(inter2);
		print(inter3);
		print(inter4);
		print(n -> n*n);
	}
	
	//STEP1
	Inter inter1 = (int n) -> { return n; };
	
	//STEP2 : 인자타입 생략
	Inter inter2 = (n) -> { return n; };
	
	//STEP3 : 매개변수가 1개면 () 생략
	Inter inter3 = n -> { return n; };
	
	//STEP4 : 실행할 명령문이 1줄이면 {} 생략 & 리턴값이 있으면 return 삭제
	Inter inter4 = n -> n*n;	
	
	void print(Inter inter) {
		System.out.println(inter.f1(5));
	}

	public static void main(String[] args) {
		new LambdaTest3();
	}
}

 

2) 매개변수와 반환값이 없을 때

interface Inter{
	void f1();
}
public class LambdaTest4 {
	public LambdaTest4() {
		print(inter1);
		print(inter2);
		print(()-> System.out.println("inner"));
	}
	
	//STEP1
	Inter inter1 = () -> { System.out.println("inter1");};
	
	//STEP2 : 실행할 명령문이 1줄이면 {} 생략
	Inter inter2 = () -> System.out.println("inter2");
	
	
	void print(Inter inter) {
		inter.f1();
	}

	public static void main(String[] args) {
		new LambdaTest4();
	}
}

 

 

 

4. lambda 활용법

1. Thread

- Runnable = FunctionalInterface

public class LambdaEx {
	public LambdaEx() {
		//1. 축약 전
		Runnable runnable = new Runnable() {
			@Override
			public void run() {
				System.out.println("hello");
			}
		};
		Thread trd = new Thread(runnable);
		
		//2. 축약 후
		Thread trd1 = new Thread(() -> System.out.println("hello"));
		trd1.start();
	}

	public static void main(String[] args) {
		new LambdaEx();
	}
}

 

2. Arrays.sort()

- 정렬하기

- sort(T[]) : 오름차순 정렬

- sort(T[], Comparator) : Comparator에 따라 정렬, Comparator = FunctionalInterface

import java.util.Arrays;
import java.util.Comparator;

public class LambdaEx {
	public LambdaEx() {
		Integer[] arr = {6, 1, 3, 11, 8};
		//1. 축약 전
		Comparator<Integer> comparator = new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return o2 - o1;
			}
		};
		//2. 축약 후
		Arrays.sort(arr, (o1, o2)-> o1 - o2);//오름차순
		Arrays.sort(arr, (o1, o2)-> -(o1 - o2));//내림차순
		System.out.println(Arrays.toString(arr));
	}

	public static void main(String[] args) {
		new LambdaEx();
	}
}