Merge pull request #315 from hwanghe159/item44

[#44][2기] 표준 함수형 인터페이스를 사용하라

7장/44_표준 함수형 인터페이스를 사용하라_황준호.md

@@ -0,0 +1,187 @@
+## 아이템44. 표준 함수형 인터페이스를 사용하라
+
+### 함수형 인터페이스를 새로 정의하기 보다는 기본 함수형 인터페이스를 사용하자
+
+`LinkedHashMap`을 이용하여 캐시를 구현한다고 생각해보자.
+
+- `removeEldestEntry`를 override하면 캐시로 사용할 수 있다.
+
+  ```java
+  public class Cache<K, V> extends LinkedHashMap<K, V> {
+
+    private final int limit;
+
+    public Cache(int limit) {
+      this.limit = limit;
+    }
+
+    @Override
+    protected boolean removeEldestEntry(Entry<K, V> eldest) {
+      return size() > this.limit;
+    }
+  }
+  ```
+
+  ```java
+  Cache<String, Integer> cache = new Cache<>(3);
+  cache.put("1", 1);
+  cache.put("2", 2);
+  cache.put("3", 3);
+  cache.put("4", 4);
+  System.out.println(String.join(", ", cache.keySet())); // 2, 3, 4
+  ```
+
+- 함수형 인터페이스로 구현할 수도 있다.
+
+  ```java
+  public class Cache<K, V> extends LinkedHashMap<K, V> {
+
+    private final EldestEntryRemovalFunction<K, V> eldestEntryRemovalFunction;
+
+    public Cache(EldestEntryRemovalFunction<K, V> eldestEntryRemovalFunction) {
+      this.eldestEntryRemovalFunction = eldestEntryRemovalFunction;
+    }
+
+    @Override
+    protected boolean removeEldestEntry(Entry<K, V> eldest) {
+      return eldestEntryRemovalFunction.remove(this, eldest);
+    }
+  }
+  ```
+
+  ```java
+  @FunctionalInterface
+  public interface EldestEntryRemovalFunction<K, V> {
+    boolean remove(Map<K, V> map, Map.Entry<K, V> eldest);
+  }
+  ```
+
+  ```java
+  Cache<String, Integer> cache = new Cache<>((map, eldest) -> map.size() > 3);
+  cache.put("1", 1);
+  cache.put("2", 2);
+  cache.put("3", 3);
+  cache.put("4", 4);
+  System.out.println(String.join(", ", cache.keySet())); // 2, 3, 4
+  ```
+
+  -> 하지만 함수형 인터페이스를 굳이 새로 만들 필요가 없다. 기존의 것을 잘 사용하면 된다.
+
+- BiPredicate 사용
+
+  ```java
+  public class Cache<K, V> extends LinkedHashMap<K, V> {
+
+    private final BiPredicate<Map<K, V>, Map.Entry<K, V>> biPredicate;
+
+    public Cache(BiPredicate<Map<K, V>, Map.Entry<K, V>> biPredicate) {
+      this.biPredicate = biPredicate;
+    }
+
+    @Override
+    protected boolean removeEldestEntry(Entry<K, V> eldest) {
+      return biPredicate.test(this, eldest);
+    }
+  }
+  // 나머지 동일
+  ```
+
+### 기본 함수형 인터페이스
+
+#### `UnaryOperator<T>` : 인수 1개, 인수의 타입 == 반환 타입
+
+- 함수 시그니처 : `T apply(T t)`
+- 예 : `String::toLowerCase`
+- 변형
+  - 기본타입용 `DoubleUnaryOperator`, `IntUnaryOperator`, `LongUnaryOperator`
+
+#### `BinaryOperator<T>` : 인수 2개, 인수의 타입 == 반환 타입
+
+- 함수 시그니처 : `T apply(T t1, T t2)`
+- 예 : `BigInteger::add`
+- 변형
+  - 기본타입용 `DoubleBinaryOperator`, `IntBinaryOperator`, `LongBinaryOperator`
+
+#### `Predicate<T>` : 인수 1개,  반환타입 == boolean
+
+- 함수 시그니처 : `boolean test(T t)`
+- 예 : `Collection::isEmpty`
+- 변형
+  - 기본타입용 `DoublePredicate`, `IntPredicate`, `LongPredicate`
+  - 인수를 2개받고 boolean 반환 `BiPredicate<T, U>`
+
+#### `Function<T,R>` : 인수의 타입 != 반환 타입
+
+- 함수 시그니처 : `R apply(T t)`
+- 예 : `Arrays::asList`
+- 변형
+  - 입력은 기본타입, 출력은 R타입 :  `DoubleFunction<R>`, `IntFunction<R>`, `LongFunction<R>`
+  - 입력과 출력 모두 기본타입(`..To..Function`) : `LongToIntFunction`, `DoubleToLongFunction` 등등...
+  - 출력이 기본타입 : `ToDoubleFunction<T>`, `ToIntFunction<T>`, `ToLongFunction<T>`
+  - 인수를 2개받고 R타입 반환 `BiFunction<T,U,R>`
+  - 인수를 2개받고 기본타입 반환 `ToDoubleBiFunction<T,U>`, `ToIntBiFunction<T,U>`, `ToLongBiFunction<T,U>`
+
+#### `Supplier<T>` : 인수 X, 반환 O
+
+- 함수 시그니처 : `T get()`
+- 예 : `Instant::now`
+- 변형
+  - 기본타입용 `DoubleSupplier`, `IntSupplier`, `LongSupplier`, `BooleanSupplier`
+
+#### `Consumer<T>` : 인수 1개, 반환 X
+
+- 함수 시그니처 : `void accept(T t)`
+- 예 : `System.out::println`
+- 변형
+  - 기본타입용 `DoubleConsumer`, `IntConsumer`, `LongConsumer`
+  - 인수 2개받는 `BiConsumer<T, U>`
+  - T타입, 기본타입 받는 `ObjDoubleConsumer<T>`, `ObjIntConsumer<T>`, `ObjLongConsumer<T>`
+
+### 기본 함수형 인터페이스에 박싱된 기본 타입을 넣어 사용하지 말라
+
+- 예)
+  - `Function<Integer, Double>` 보다는 `IntToDoubleFunction`
+  - `Supplier<Long>` 보다는 `LongSupplier`
+  - 등등 ...
+
+### 표준 함수형 인터페이스 대신 직접 구현해야 할 때도 있다
+
+```java
+@FunctionalInterface
+public interface Comparator<T> {
+  int compare(T o1, T o2);
+  //이하 생략
+}
+```
+
+1. 자주 쓰이며, 이름 자체가 용도를 명확히 설명해준다
+   - 예 : 구조적으로는 `ToIntBiFunction<T,U>`와 같지만 `Comparator<T>`라는 이름이 훨씬 명확하다
+2. 반드시 따라야 하는 규약이 있다
+   - 예 : `compare()` 는 따라야 하는 규약이 많다
+3. 유용한 디폴트 메서드를 제공할 수 있다
+   - 예 : `Comparator<T>`는 `reversed()`, `thenComparing()` 등등의 메서드를 제공한다
+
+이 중 하나 이상을 만족한다면 전용 함수형 인터페이스를 구현해야 하는 건 아닌지 고민해야 한다.
+
+### 함수형 인터페이스를 직접 구현할 때의 주의사항
+
+- `@FunctionalInterface`를 붙여야 한다
+
+  - 해당 인터페이스가 람다용으로 설계된 것임을 명확하게 알려준다
+  - 해당 인터페이스가 추상 메서드를 오직 하나만 가지고 있어야 컴파일이 되도록 한다 -> 누군가 실수로 메서드를 추가할 수 없게 막아준다
+
+- 서로 다른 함수형 인터페이스를 같은 위치의 인수로 받는 메서드들을 오버로딩하면 안된다.
+
+  ```java
+  public interface ExecutorService extends Executor {
+    // ...
+
+    <T> Future<T> submit(Callable<T> task);
+    Future<?> submit(Runnable task);
+
+    // ...
+  }
+  ```
+
+  - 올바른 메서드를 알려주기 위해 형변환을 해야 할때가 많이 생긴다 (아이템52)
+  - 함수형 인터페이스의 위치를 다르게 해서 오버로딩하자.