함수형 인터페이스(Functional Interfaces)
📌 함수형 인터페이스(Functional Interfaces)
: 추상 메소드 하나만 가지는 인터페이스.
📌 람다식은 함수형 인터페이스를 기반으로만 작성할 수 있음.
📌 @FunctionalInterface
: 함수형 인터페이스에 부합하는 지 확인하기 위한 어노테이션 타입.
📌 static, default 선언은 함수형 인터페이스 정의에 영향을 주지 않음.
📌 제네릭으로 정의된 함수형 인터페이스를 대상으로 람다식 작성 가능.
📄 GenericLambdaTest.java
package lambda;
@FunctionalInterface
interface Calculate <T> { // 제네릭으로 정의된 함수형 인터페이스.
T cal(T a, T b);
}
public class GenericLambdaTest {
public static void main(String[] args) {
Calculate<Integer> ci = (a, b) -> a + b;
System.out.println(ci.cal(5, 2)); // 7
Calculate<Double> cd = (a, b) -> a + b;
System.out.println(cd.cal(5.1235, 2.4321)); // 7.5556
}
}
📌 정의되어 있는 함수형 인터페이스
Predicate<T> | boolean test(T t) |
Supplier<T> | T get( ) |
Consumer<T> | void accept(T t) |
Function<T, R> | R apply(T t) |
Predicate<T>
📌 boolean test(T t); 추상 메소드 존재.
: 전달된 인자를 판단해 true, false 반환.
📌 Predicate<T>를 구체화, 다양화 한 인터페이스
IntPredicate | boolean test(int value) |
LongPredicate | boolean test(lona value) |
DoublePredicate | boolean test(double value) |
📄 PredicateTest.java
package lambda;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class PredicateTest {
public static <T> void show(Predicate<T> p, List<T> li) {
for(T n : li) {
if(p.test(n)) {
System.out.print(n + " ");
}
}
}
public static void main(String[] args) {
List<Integer> li1 = Arrays.asList(1, 3, 4, 8, 10, 11);
show(n -> n%2 != 0, li1); // 홀수만 출력. // 1 3 11
System.out.println();
List<Double> li2 = Arrays.asList(-3.5, 6.2, 5.1, -8.9);
show(n -> n > 0.0, li2); // 0.0보다 큰 수만 출력. // 6.2 5.1
}
}
Supplier<T>
📌 T get( ); 추상 메소드 존재.
: 무언가를 반환할 때 사용.
📌 Supplier<T>를 구체화, 다양화 한 인터페이스
IntSupplier | int getAsInt( ) |
LongSupplier | long getAsLong( ) |
DoubleSupplier | double getAsDouble( ) |
BooleanSupplier | boolean getAsBoolean( ) |
📄 SupplierTest.java
package lambda;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
public class SupplierTest {
public static List<Integer> mkIntList(Supplier<Integer> s, int n) {
List<Integer> li = new ArrayList<>();
for(int i = 0; i < n; i++) {
li.add(s.get());
}
return li;
}
public static void main(String[] args) {
Supplier<Integer> sp = () -> {
Random rand = new Random();
return rand.nextInt(100);
};
List<Integer> li = mkIntList(sp, 10); // [27, 69, 95, 95, 6, 92, 53, 27, 84, 62]
System.out.println(li);
li = mkIntList(sp, 20);
System.out.println(li); // [93, 84, 39, 25, 66, 8, 13, 49, 98, 94, 15, 54, 18, 61, 74, 49, 13, 5, 44, 47]
}
}
Consumer<T>
📌 void accept(T t); 추상 메소드 존재.
: 반환 이외의 다른 결과를 보일 때 사용.
📌 Consumer<T>를 구체화, 다양화 한 인터페이스
IntConsumer | void accept(int value) |
ObjIntConsumer<T> | void accept(T t, int value) |
LongConsumer | void accept(long value) |
ObjLongConsumer<T> | void accept(T t, long value) |
DoubleConsumer | void accept(double value) |
ObjDoubleConsumer<T> | void accept(T t, double value) |
BiConsumer<T, U> | void accept(T t, U u) |
📄 ConsumerTest.java
package lambda;
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
Consumer<String> c = s -> System.out.println(s);
c.accept("hi"); // hi
c.accept("Nice to meet you"); // Nice to meet you
}
}
Function<T, R>
📌 R apply(T t); 추상 메소드 존재.
: 전달 인자와 반환 값이 모두 존재할 때.
📌 Function<T, R>를 구체화, 다양화 한 인터페이스
IntToDoubleFunction | double applyAsDouble(int value) |
DoubleToIntFunction | int applyAsInt(double value) |
💡 인터페이스 규칙
- 반환형과 매개변수형이 동일한 인터페이스 : Operator로 끝남.
- 매개변수가 하나인 인터페이스 : 앞에 Unary가 붙음.
📄 FunctionTest.java
package lambda;
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
Function<Double, Double> cti = d -> d * 0.393701;
Function<Double, Double> itc = d -> d * 2.54;
System.out.println("1cm = " + cti.apply(1.0) + "inch"); // 1cm = 0.393701inch
System.out.println("1inch = " + itc.apply(1.0) + "cm"); // 1inch = 2.54cm
}
}
'Java > Java' 카테고리의 다른 글
[Java] 중간 연산 - 필터링(Filtering)과 맵핑(Mapping) (0) | 2022.10.21 |
---|---|
[Java] 스트림 (0) | 2022.10.21 |
[Java] 람다(Lambda) (0) | 2022.10.20 |
[Java] 네스티드 클래스(Nested Class)와 이너 클래스(Inner Class) (0) | 2022.10.20 |
[Java] 컬렉션 프레임워크 - Map<K, V> 인터페이스 (0) | 2022.10.18 |
댓글