μμ κΈμ μ΄μ΄μ λλ€μμ μ΄ν΄λ³΄μ. μ΄λ²μλ java.util.function ν¨ν€μ§μ ν¨μν μΈν°νμ΄μ€μ λ©μλ μ°Έμ‘°μ λν΄μ μμλ³Ό κ²μ΄λ€.
1. ν¨μν μΈν°νμ΄μ€ π
ν¨μν μΈν°νμ΄μ€μ λν μ€λͺ μ΄ νμνλ€λ©΄ μμ κΈμ μ°Έκ³ νκΈ°λ₯Ό λ°λλ€. μ¬κΈ°μλ java.util.functionμμ μ 곡νλ ν¨μν μΈν°νμ΄μ€μ μ’ λ₯μ μ¬μ©λ²μ λν΄μλ§ μμλ³΄κ³ μ νλ€.
ν¨μν μΈν°νμ΄μ€ | λ©μλ | μ€λͺ |
Runnable | void run() | 맀κ°λ³μ X, λ°νκ° X |
Supplier<T> | T get() | 맀κ°λ³μ X, λ°νκ° O |
Consumer<T> | void accept(T t) | 맀κ°λ³μ O, λ°νκ° X |
Function<T, R> | R apply(T t) | 맀κ°λ³μ O, λ°νκ° O |
Predicate<T> | boolean test(T t) | 맀κ°λ³μ O, λ°νκ° O(boolean) |
public static void main(String[] args) {
// 맀κ°λ³μ X, λ°νκ° X
Runnable runnable = () -> System.out.println("Runnable Test");
runnable.run();
// 맀κ°λ³μ X, λ°νκ° O
Supplier<String> supplier = () -> "Supplier Test";
System.out.println(supplier.get());
// 맀κ°λ³μ O, λ°νκ° X
Consumer<String> consumer = (something) -> System.out.println(something + "μ(λ₯Ό) μ»μμ΅λλ€.");
consumer.accept("λ
ΈνΈλΆ");
// 맀κ°λ³μ O, λ°νκ° O
Function<Integer, Integer> multiplyByTwo = (a) -> a * 2;
System.out.println(multiplyByTwo.apply(5));
// 맀κ°λ³μ O, λ°νκ° boolean
int avg = 80;
Predicate<Integer> isBiggerThanAvg = (number) -> number < avg;
System.out.println(isBiggerThanAvg.test(100));
}
// Runnable Test
// Supplier Test
// λ
ΈνΈλΆμ(λ₯Ό) μ»μμ΅λλ€.
// 10
// false
ν¨μν μΈν°νμ΄μ€ | λ©μλ | μ€λͺ |
BiConsumer<T, U> | void accept(T t, U u) | 맀κ°λ³μ 2κ°, λ°νκ° X |
BiPredicate<T, U> | boolean test(T t, U u) | 맀κ°λ³μ 2κ°, λ°νκ° O (boolean) |
BiFunction<T, U, R> | R apply(T t, U u) | 맀κ°λ³μ 2κ°, λ°νκ° O |
public static void main(String[] args) {
// 맀κ°λ³μ 2κ°, λ°νκ° X
BiConsumer<String, Integer> applyCompany = (company, count) ->
System.out.println(company + "νμ¬μ " + count + "λ² μ§μνμμ΅λλ€.");
applyCompany.accept("ABC", 3);
// 맀κ°λ³μ 2κ°, λ°νκ° O (boolean)
int maxCount = 5;
BiPredicate<Integer, Integer> canRedo = (count, maximum) -> count < maximum;
System.out.println(canRedo.test(3, maxCount));
// 맀κ°λ³μ 2κ°, λ°νκ° O
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
System.out.println(add.apply(3, 4));
}
}
// ABCνμ¬μ 3λ² μ§μνμμ΅λλ€.
// true
// 7
ν¨μν μΈν°νμ΄μ€ | λ©μλ | μ€λͺ |
UnaryOperator<T> | T apply(T t) | 맀κ°λ³μμ νμ = λ°νκ°μ νμ |
BinaryOperator<T> | T apply(T t, T t) | 맀κ°λ³μ νμ
= λ°νκ°μ νμ
(맀κ°λ³μλ 2κ°μ΄κ³ λμ νμ μ λμΌνλ€.) |
public static void main(String[] args) {
// 맀κ°λ³μμ νμ
= λ°νκ°μ νμ
UnaryOperator<Integer> multiplyByTwo = (a) -> a * 2;
System.out.println(multiplyByTwo.apply(5));
// 맀κ°λ³μμ νμ
= λ°νκ°μ νμ
// 맀κ°λ³μλ 2κ°μ΄κ³ λμ νμ
μ λμΌνλ€.
BinaryOperator<String> appendString = (a, b) -> a + b;
System.out.println(appendString.apply("abc", "def"));
}
// 10
// abcdef
컬λ μ νλ μμν¬μ μΈν°νμ΄μ€μ μΆκ°λ λ€μμ λν΄νΈ λ©μλλ€ μ€μ μΌλΆλ μλμ κ°μ΄ ν¨μν μΈν°νμ΄μ€λ₯Ό μ¬μ©νλ€.
μΈν°νμ΄μ€ | λ©μλ | μ€λͺ |
Collection | boolean removeIf(Predicate<E> filter) | 쑰건μ λ§λ μμλ₯Ό μμ |
List | void replaceAll(UnaryOperator<E> operator) | λͺ¨λ μμλ₯Ό λ³ννμ¬ λ체 |
Iterable | void forEach(Consumer<T> action) | λͺ¨λ μμμ μμ actionμ μν |
Map | V compute(K key, BiFunction(K, V, V> f) | μ§μ λ ν€μ κ°μ μμ fλ₯Ό μν |
V computeIfAbsent(K key, Function<K, V> f) | ν€κ° μμΌλ©΄, μμ f μν ν μΆκ° | |
V computeIfPresent(K key, BiFunction<V, V, V> f) | μ§μ λ ν€κ° μμ λ, μμ f μν | |
V merge(K key, V value, BiFunction<V, V, V> f) | λͺ¨λ μμμ λ³ν©μμ fλ₯Ό μν | |
voi forEach(BiConsumber<K, V> action) | λͺ¨λ μμμ μμ actionμ μν | |
void replaceAll(BiFunction<K, V, V> f) | λͺ¨λ μμμ μΉνμμ fλ₯Ό μν |
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("κΉλ무 νμ");
list.add("μ΅λ°λ€ νμ");
list.add("κΉκ³Όκ±°");
list.add("λ°νμ€");
list.add("μ΅λ―Έλ");
System.out.println(list);
list.removeIf(name -> name.contains("νμ"));
System.out.println(list);
list.replaceAll(name -> name + " μ μλ");
System.out.println(list);
list.forEach(name -> System.out.print(name + ", "));
}
// [κΉλ무 νμ, μ΅λ°λ€ νμ, κΉκ³Όκ±°, λ°νμ€, μ΅λ―Έλ]
// [κΉκ³Όκ±°, λ°νμ€, μ΅λ―Έλ]
// [κΉκ³Όκ±° μ μλ, λ°νμ€ μ μλ, μ΅λ―Έλ μ μλ]
// κΉκ³Όκ±° μ μλ, λ°νμ€ μ μλ, μ΅λ―Έλ μ μλ,
2. λ©μλ μ°Έμ‘°(Method Reference) π±
λλ€μμ μ΄μ©νμ¬ λ무λλ κ°λ¨νκ² λ©μλλ₯Ό ννν μ μμλ€. κ·Όλ°, μ΄κ²λ³΄λ€ λ κ°λ΅νκ² ννν μ μμκΉ? λ©μλ μ°Έμ‘°λΌλ λ°©λ²μ μ΄μ©νμ¬ λλ€μμ λ κ°λ΅νκ² ννν΄ λ³΄μ. λͺ¨λ λλ€μμ μ μ© κ°λ₯ν κ²μ μλκ³ λλ€μμ΄ νλμ λ©μλλ§ νΈμΆνλ κ²½μ°μλ§ μ¬μ©ν μ μλ€.
μ’ λ₯ | λλ€ | λ©μλ μ°Έμ‘° |
static λ©μλ μ°Έμ‘° | (x) -> ClassName.method(x) | ClassName::method |
μΈμ€ν΄μ€ λ©μλ μ°Έμ‘° | (obj.x) -> obj.method(x) | ClassName::method |
νΉμ κ°μ²΄ μΈμ€ν΄μ€ λ©μλ μ°Έμ‘° | (x) -> obj.method(x) | obj::method |
// static λ©μλ μ°Έμ‘°
Function<String, Integer> f1 = (String s) -> Integer.parseInt(s);
Function<String, Integer> f2 = Integer::parseInt;
// μΈμ€ν΄μ€ λ©μλ μ°Έμ‘°
BiFunction<String, String, Boolean> f3 = (s1, s2) -> s1.equals(s2);
BiFunction<String, String, Boolean> f4 = String::equals;
// νΉμ κ°μ²΄ μΈμ€ν΄μ€ λ©μλ μ°Έμ‘°
MyClass obj = new MyClass();
Function<String, Boolean> f5 = (x) -> obj.equals(x);
Function<String, Boolean> f6 = obj::equals;
λ©μλ μ°Έμ‘°λ₯Ό μ¬μ©νλ©΄ λλ€μμ μΌλΆκ° μλ΅μ΄ λλ€. νμ§λ§ μ»΄νμΌλ¬κ° μλ΅λ λΆλΆμ μΈν°νμ΄μ€μ λ©μλ μ μΈλΆλ₯Ό ν΅ν΄μ μ½κ² μμλΌ μ μκΈ° λλ¬Έμ λ¬Έμ κ° λμ§ μλλ€.
μμ±μλ₯Ό νΈμΆνλ λλ€μλ λ©μλ μ°Έμ‘°λ‘ λ³νν μ μλ€.
Supplier<ClassA> s1 = () -> new ClassA();
Supplier<ClassA> s2 = ClassA::new;
Function<Integer, int[]> f1 = x -> new int[x];
Function<Integer, int[]> f2 = int[]::new;
λλ€μκ³Ό λ©μλ μ°Έμ‘°λ₯Ό μκΈ΄ ν΄λ μ΅μνμ§ μμΌλ©΄ μ μ¬μ©νμ§ λͺ»νλ κ±° κ°λ€. κ°μ΄ μ°μ΅ν΄μ μΌλ₯Έ μ΅μν΄μ§λλ‘ νμ.
ν΄λΉ κΈμ λ¨κΆ μ±λμ Javaμ μ μμ μ½κ³ μμ±ν κ²μ λλ€.
'π JAVA > μ£Όμ κ°λ ' μΉ΄ν κ³ λ¦¬μ λ€λ₯Έ κΈ
μ μΆλ ₯(I/O)(2) - μ§λ ¬ν(Serialization) (2) | 2023.01.29 |
---|---|
μ μΆλ ₯(I/O)(1) - λ Έλ μ€νΈλ¦Ό, 보쑰 μ€νΈλ¦Ό (0) | 2023.01.29 |
λλ€μ(Lambda Expression) - (1) (0) | 2023.01.29 |
Comparableκ³Ό Comparator (0) | 2023.01.28 |
μμΈμ²λ¦¬(Exception Handling) - (2) (0) | 2023.01.28 |