[백엔드개발자 준비하기] 람다

public class Lambda1 {

	public static void main(String[] args) {
		Instrument instrument = new Instrument() {
			
			@Override
			public String play(String instrument) {
				
				return instrument + "을(를) 연주합니다.";
			}
		};
		
		// 람다를 사용할수 있는 인터페이스 : 추상메소드를 하나만 가진 인터페이스
		Instrument instrument2 = (String itm) -> {
			return itm + "을(를) 연주합니다.";
		};
		
		// 매개변수의 자료형을 생략할 수 있다
		// 매개변수의 이름을 바꿀 수 있다
		Instrument instrument3 = (itm) -> {
			return itm + "을(를) 연주합니다.";
		};
		
		// 매개변수가 하나이면 매개변수를 감싸는 괄호를 생략할 수 있다
		Instrument instrument4 = itm -> {
			return itm + "을(를) 연주합니다.";
		};

		// 구현부의 명령이 하나일 때 중괄호를 생략할 수 있다
		// 이때 리턴자료형이 정해져 있으면 리턴값으로 사용이 된다.
		// 중괄호를 생략하면 리턴도 생략해야함
		Instrument instrument5 = itm -> itm + "을(를) 연주합니다.";
		
		int result = 10 + 20;
		
		Instrument instrument6 = itm -> itm + "을(를) 연주합니다." + result;		
		
		System.out.println(instrument.play("피아노"));
		
		String playText = instrument.play("드럼");
		System.out.println(playText);
		
		System.out.println(instrument6.play("기타"));
	}
}

public class lambda2 {

	public static void main(String[] args) {
		
		// 1. Runnable - run()
		Runnable a = () -> System.out.println("실행");
		Runnable b = () -> {
			System.out.println("여");
			System.out.println("러");
			System.out.println("명");
			System.out.println("령");
			System.out.println("실");
			System.out.println("행");
		};
		
		a.run();
		b.run();
		
		// 2. Supplier<T> - T get()
		Supplier<LocalDate> c = () -> LocalDate.now();
		Supplier<String> d = () -> {
			LocalDate now = LocalDate.now();
			return now.format(DateTimeFormatter.ofPattern("yyyy년 MM월 dd일"));
		};
		
		System.out.println(c.get());
		System.out.println(d.get());
		
		// 3. Consumer<T> - void accept(T t)
		Consumer<String> e = name -> {
			System.out.println("이름 : " + name);
			System.out.println("오늘 날짜 : " + d.get());
			
		};
		
		e.accept("이종현");
		
		// 메소드 참조 표현식 ([인스턴스] :: [메소드명 또는 new])
		Consumer<String> f = System.out :: println;
		f.accept("출력");
		
		List<String> names = new ArrayList<>();
		names.add("김동민");
		names.add("김두영");
		names.add("장진원");
		names.add("조병철");
		
		Consumer<String> g = name -> System.out.println("이름 : " + name + "님");
		names.forEach(g);
		
		// this = names
		
//		default void forEach(Consumer<? super T> action) {
//			Objects.requireNonNull(action);
//			for (String t : this) {
//				action.accept(t);
//			}
//		}
		
		names.forEach(name -> {
			System.out.println("이름을 출력합니다.");
			System.out.println("이름 : " + name);
			System.out.println();
		});
		
		Map<String, String> userMap = new HashMap<>();
		userMap.put("username", "aaa");
		userMap.put("password", "1234");
		
		userMap.forEach((key, value) -> {
			System.out.println("key : " + key);
			System.out.println("value : " + value);
			System.out.println();
		});
		
		for(Entry<String, String> entry : userMap.entrySet()) {
			System.out.println("key : " + entry.getKey());
			System.out.println("value : " + entry.getValue());
			System.out.println();
		}
		
		// 4. Function<T, R>
		
		Function<String, Integer> h = num -> Integer.parseInt(num);
		
		int convertStrNum1 = h.apply("10000");
		int convertStrNum2 = h.apply("20000");
		
		System.out.println(convertStrNum1 + convertStrNum2);
		
		// 5. Predicate<T>
		
		Predicate<String> p = str -> str.contains("김");
		Predicate<String> p2 = str -> str.contains("이");
		
		Function<Predicate<String>, Boolean> function1 = 
				predicate -> predicate.or(str -> str.startsWith("이")).test("김준일");
		
		boolean rs = function1.apply(str -> str.startsWith("김"));
		
		System.out.println(rs);
		
		List<String> nameList = new ArrayList<>();
		names.add("김종홤");
		names.add("고병수");
		names.add("김상현");
		names.add("김준경");
		
		Stream<String> stream = nameList.stream().filter(name -> name.startsWith("김"));
		//stream.forEach(name -> System.out.println(name)); 
//		List<String> newList = stream.map(Collection :: stream).collect(Collectors.toList());
		
		nameList.stream()
		.filter(name -> name.startsWith("김"))
		.collect(Collectors.toList())
		.forEach(name -> System.out.println(name));
		}
}