Java 8 함수형 인터페이스 이해하기

 

목차

· 함수형 인터페이스란?

· 기본 함수형 인터페이스

· Supplier 

· Consumer

· BiConsumer

· Predicate

· Comparator

---

 

 

이전 글에서 Java 람다 표현식과 함수형 인터페이스에 대해서 다뤘었다.

함수형 인터페이스란?

---

함수형 인터페이스(Functional interface)는 1개의 추상 메서드를 갖고 있는 인터페이스이다. 

Java에서는 기본적으로 java.util.function 패키지에서 여러 함수형 인터페이스를 제공한다.

오늘은 기본적인 여러 함수형 인터페이스를 다뤄볼 것이다.

 

기본 함수형 인터페이스

---

기본적인 함수형 인터페이스에는 다음 인터페이스들이 있다.

 

• Supplier
• Consumer
• BiConsumer
• Predicate
• Comparator

Supplier

---

@FunctionalInterface
public interface Supplier<T> { 
	T get();
}

Supplier 인터페이스는 get을 추상메소드로 가진다. get 메서드는 인풋 값 없이 특정 값을 반환한다.

 

Supplier 인터페이스를 이용해 특정 랜덤 값을 반환하도록 했습니다.

Supplier<Double> doubleRandomSupplier = () -> Math.random();
System.out.println("random = " + doubleRandomSupplier.get());

// random = 0.3081727368722452

 

Consumer

---

Consumer 인터페이스는 accept를 추상메소드를 가진다. accept는 인풋 값을 가지고 아무것도 반환하지 않는다.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

Consumer 인터페이스를 이용해 한 개의 인풋 값을 출력하도록 했다.

Consumer<Integer> integerConsumer = i-> System.out.println("i = " + i);
integerConsumer.accept(5);

// i = 5

BiConsumer

---

BiConsumer는 accept를 추상메소드로 가진다. accept는 두 개의 인풋 값을 가지며 아무것도 반환하지 않는다.

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

BiConsumer 인터페이스를 이용해 두 개의 인풋 값을 출력하도록 했다.

BiConsumer<Integer, Integer> integerConsumer = (i, j)-> System.out.println("i = " + i +", j = "+ j);
integerConsumer.accept(5, 10);

// i = 5, j = 10

Predicate

---

Predicate는 test를 추상 메소드로 가진다. test는 특정 인풋을 가지고 true나 false 값을 반환한다.

 

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

Predicate 인터페이스는 and, or 디폴트 메서드가 존재하며 Predicate를 매개변수로 받고 Predicate를 반환하는 형식으로 되어있다.

default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
}

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

Predicate 인터페이스를 사용한 예시는 다음과 같다.

Predicate<Integer> isPositive = x-> x>0;
System.out.println("result = " + isPositive.test(11));
System.out.println("0 이상 정수 = " + isPositive.or(x->x==0).test(11));
System.out.println("짝수= " + isPositive.and(x->x%2==0).test(11));

// result = true
// 0 이상 정수 = true
// 짝수= false

 

Comparator

---

Comparator는 java.util 패키지에 있고, 비교를 위한 인터페이스이다.

T라는 타입의 매개변수를 두 개 받고 두 객체의 우선순위를 알려준다.

@FunctionalInterface
public interface Comparator<T> {
       int compare(T o1, T o2);
}

• 음수면 o1 <o2 , o1이 더 높은 우선순위를 갖음
• 0이면 o1=o2
• 양수면 o1> o2

Comparator 인터페이스를 사용해 나이와 이름별로 유저를 정렬했다.

ArrayList<User> users = new ArrayList<>();
users.add(new User("Kim", 10));
users.add(new User("Char", 30));
users.add(new User("Boo", 50));

Comparator<User> ageComparator = (u1, u2) -> u1.getAge() - u2.getAge();
Collections.sort(users, ageComparator);
System.out.println("나이를 기준으로 오름차순 = " + users);

Collections.sort(users, (u1,  u2) -> u1.getName().compareTo(u2.getName()));
System.out.println("이름을 기준으로 알파벳 오름차순 = " + users);

// 나이순 오름차순 = [User{name='Kim', age=10}, User{name='Char', age=30}, User{name='Boo', age=50}]
// 이름을 기준으로 알파벳 오름차순 = [User{name='Boo', age=50}, User{name='Char', age=30}, User{name='Kim', age=10}]