람다식(Lambda Expression)

Ex87 ~ Ex90

 

람다식, Lambda Expression
- 함수형 프로그래밍 방식을 지원하는 표현식
- 람다식을 사용하면 코드 일부가 간결해진다.(호불호)
- Java 8 출시
- 목적 > 컬렉션(배열) 조작

- 자바의 메소드를 표현하는 방법 중 하나로 사용
- 람다식은 메소드를 대신하는 코드블럭이다.
- 자바의 람다식은 인터페이스를 사용해서 만든다.
- 자바의 람다식은 익명 객체(추상 메소드)를 만드는 표현을 간소화시킨 기술이다.

- 람다식을 저장하는 인터페이스는 반드시 Fuctional Interface이어야 한다.(추상 메소드를 딱 1개만 가져야합니다.) > 


람다식 형식
- 인터페이스 변수 = 람다식
- MyInterface m3 = () -> {};

(매개변수) -> {구현부};
a. (매개변수): 메소드의 인자리스트
b. ->: 화살표(Arrow), 구현부를 호출하는 역할
c. {}: 메소드의 구현부


public void test() {
syso();
}

//익명 메소드(함수)
() -> {
syso();
}

 

 

 

요구사항] MyInterface를 구현한 객체를 생성하시오.

		//1. 클랙스 + 객체
		MyInterface m1 = new MyClass(); 
		m1.test();
		
		//2. 익명 객체 
		MyInterface m2 = new MyInterface() {
			@Override
			public void test() {
				System.out.println("익명 클래스에서 구현한 메소드");
			}
		};
		m2.test();
		
		
		//3. 람다식
		MyInterface m3 = () -> {
			System.out.println("람다식으로 구현한 메소드");
		};
		m3.test();
		
		
		TestInterface t1 = new TestInterface() {
			
			@Override
			public void bbb() {
				System.out.println("B");
			}
			
			@Override
			public void aaa() {
				System.out.println("A");
			}
		};
		
		
		
		//The target type of this expression must be a functional interface
//		TestInterface t2 = () -> {
//			//aaa() or bbb()
//		};
//		
//		t2.aaa();
//		t2.bbb();
		
		
		
		//추상 메소드 형식에 따라..
		//- 매개변수 O, X
		//- 반환값 O, X
		
		
		NoParameterNoReturn pr1 = new NoParameterNoReturn() {
			
			@Override
			public void call() {
				System.out.println("pr1");
			}
		};
		pr1.call();
		
		NoParameterNoReturn pr2 = () -> {
			System.out.println("pr2");
		};
		pr2.call();
		
		//** 람다식 구현부에 실행문장 1줄이면 {} 생략
		NoParameterNoReturn pr3 = () -> System.out.println("pr3");
		pr3.call();
		
		
		//void call(int n)
		ParameterNoReturn pr4 = (int n) -> {
			System.out.println("pr4: " + n);
		}; 
		pr4.call(100);
		pr4.call(200);
		pr4.call(300);
		
		
		//** 매개변수의 자료형을 생략할 수 있다. 
		ParameterNoReturn pr5 = (n) -> {
			System.out.println("pr5: " + n);
		};
		pr5.call(400);
		
		//** 매개변수의 ()를 생략할 수 있다.
		ParameterNoReturn pr6 = n -> {
			System.out.println("pr6: " + n);
		};
		pr6.call(500);
		
		ParameterNoReturn pr7 = n -> System.out.println("pr7: " + n);
		pr7.call(600);
		
		
		//void call(String name, int age);
		MultiParameterNoReturn pr8 = (String name, int age) -> {
			System.out.println("pr8: " + name + "," + age);
		};
		pr8.call("홍길동", 20);
		
		MultiParameterNoReturn pr9 = (name, age) -> {
			System.out.println("pr9: " + name + "," + age);
		};
		pr9.call("홍길동", 20);	
		
		//** 매개변수의 ()는 매개변수가 1개일 때만 생략 가능하다.(없을때도 생략 불가)
//		MultiParameterNoReturn pr10 = name, age -> {
//			System.out.println("pr10: " + name + "," + age);
//		};
		
		
		//int call();
		NoParameterReturn pr11 = () -> {
			return 100;
		}; 
		System.out.println("pr11: " + pr11.call());
		
		//** 구현부에 return문이 유일하면, {}와 return을 생략할 수 있다.
		NoParameterReturn pr12 = () -> 200;
		System.out.println("pr12: " + pr12.call());
		
		
		
		//int call(int a, int b);
		ParameterReturn pr13 = (int a, int b) -> {
			return a + b;
		};
		System.out.println("pr13: " + pr13.call(10, 20));
		
		
		ParameterReturn pr14 = (a, b) -> a + b;
		System.out.println("pr14: " + pr14.call(30, 40));
		
		
		
		
		
		
		
	}//main

}//main class


//functional interface
//- 추상 메소드를 딱 1개만 가지는 인터페이스
interface MyInterface {
	void test();
}

class MyClass implements MyInterface {
	@Override
	public void test() {
		System.out.println("MyClass 클래스에서 구현한 메소드");
	}
}


interface TestInterface {
	void aaa();
	void bbb();
}



interface NoParameterNoReturn {
	void call();
}

interface ParameterNoReturn {
	void call(int n);
}

interface MultiParameterNoReturn {
	void call(String name, int age);
}

interface NoParameterReturn {
	int call();
}

interface ParameterReturn {
	int call(int a, int b);
}

 

Ex88

		ArrayList<Integer> list = new ArrayList<Integer>();
		
		for (int i=0; i<20; i++) {
			
			list.add((int)(Math.random() * 100) + 1);
			
		}
		
		System.out.println(list);
		
		
		list.sort(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				
				return o2 - o1;
			}
		});
		System.out.println(list);
		
		//람다식. 위와 똑같은 식
		list.sort((o1, o2) -> o2 - o1);
		System.out.println(list);