[Java 8] Java 8과 함수형 인터페이스

더 자바, Java 8

 

이 포스팅에서 작성하는 내용은 더 자바, Java 8 에서 발췌하였습니다.

 

https://www.inflearn.com/course/the-java-java8

더 자바, Java 8 - 인프런 | 강의

 

---

Java 8

• 2014년 3월 출시
• 현재 자바 개발자의 80% 이상이 사용
• LTS 버전
  • LTS? Java에서 주기적으로 업데이트를 제공해주는 버전. 실제 운영 환경에서는 LTS 버전을 권장
  • LTS 버전이 아닌 건, 업데이트 제공 기간이 짧다.
• 주요 추가 기능 : 람다 표현식, 메서드 레퍼런스, 스트림 API, Optional, 함수형 인터페이스 등

 

 

함수형 인터페이스

• 인터페이스에 추상 메서드가 하나만 있는 인터페이스 (abstract)
• 다른 static, default 메서드는 몇 개가 있든 상관 X
• @FunctionalInterface 어노테이션을 추가하면, 함수형 인터페이스를 관리하기 수월
  (추상 메서드가 2개 이상이 되면 컴파일 단계에서 오류)
• 함수형 인터페이스의 경우, 추상 메서드를 재정의하는 방법으로 람다 표현식이 가능하다.
  (기존에는, 익명 내부 클래스 방식)
• 순수 함수여야 함
  • 부수 효과 X (함수 밖의 변수를 변경하지 않음)
  • 상태 X (함수 밖의 변수를 사용하지 않음)
• 고차 함수 (함수가 함수를 매개 변수로 받을 수도 있고, 리턴 할 수도 있음)
• 불변성 (변하지 말아야 함)

 

람다 표현식

• 함수형 인터페이스 인스턴스를 만드는 데 사용할 수 있는 표현식
• 코드를 간결하게 해줌
• 메소드 매개변수, 리턴 타입, 변수로 만들어 사용 가능

public class Example1 {

	public static void main(String[] args) {
		
		/** 함수형 인터페이스의 추상 메서드를 정의하는 방법 **/
		
		// 기존의 익명 내부 클래스 방식 (anonymous inner class)
		ExampleInterface1 interface1 = new ExampleInterface1() {
			@Override
			public void doIt() {
				// TODO Auto-generated method stub
				System.out.println("doIt1 !!!");
			}
		};
		interface1.doIt();
		
		// 람다 표현식 방식 (lambda Expression)
		ExampleInterface1 interface2 = () -> System.out.println("doIt2 !!!");
		interface2.doIt();
	}

}

 

 

 

Java의 기본 함수형 인터페이스

• Java에서 기본적으로 제공하는 함수형 인터페이스
• 이 인터페이스를 이용하여 Stream을 간편하게 사용할 수 있음

함수	설명	메서드
Function<T, R>	T타입을 받아서 R타입을 반환	* R apply(T t) - andThen - compose
BiFunction<T, U, R>	두 파라미터(T타입, U타입)를 받아서 R타입으로 반환	* R apply(T t, U u)
Consumer<T>	T타입을 받아서 어떤 값도 반환 X	* R accept(T t) - andThen
Supplier<T>	T타입의 값을 반환	* T get()
Predicate<T>	T타입을 받아서 boolean을 반환	* boolean test(T t) - And - Or - Negate
UnaryOperator<T>	Function<T, R> 에서 입력 값과 동일한 타입으로 반환
BinaryOperator<T>	BiFunction<T, U, R> 에서 동일한 타입의 입력값 2개를 동일한 타입으로 반환

https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

java.util.function (Java Platform SE 8 )

 

import java.util.function.*;

public class Example2 {
	public static void main(String[] args) {
		
		/** Function<T, R> **/
		System.out.println("Function");
		// 1. apply
		Function<Integer, Integer> plus50 = (num) -> num+50;
		System.out.println(plus50.apply(10));

		Function<Integer, Integer> divide = (num) -> num/2;
		System.out.println(divide.apply(10));
		
		// 2. compose
		// compose 메서드 안에 있는 인자가 먼저 실행됨. (아래에서는 divide)
		Function<Integer, Integer> divideAndPlus50 = plus50.compose(divide);
		System.out.println(divideAndPlus50.apply(10));
		
		// 3.andThen
		// compose 와 순서가 반대.
		Function<Integer, Integer> plus50AndDivide = plus50.andThen(divide);
		System.out.println(plus50AndDivide.apply(10));
		
		
		
		/** UnaryOperator **/
		System.out.println("UnaryOperator");
		UnaryOperator<Integer> plus500 = (num) -> num+500;
		System.out.println(plus500.apply(10));
		
		
		
		/** Consumer **/
		System.out.println("Consumer");
		Consumer<Integer> doPrint = i -> System.out.println(i);
		doPrint.accept(30);
		
		
		
		/** Supplier **/
		System.out.println("Supplier");
		Supplier<Integer> get100 = () -> 100;
		System.out.println(get100.get());
		
		
		
		/** Predicate**/ 
		System.out.println("Predicate");
		Predicate<Integer> isEqual50 = (num) -> num==50;		// 50과 다르면 false, 같으면 true 반환
		System.out.println(isEqual50.test(100));
	}
	

}