[CHAPTER 2] - 동작 파라미터화 코드 전달하기

[BvrPark]

동작 파라미터화 코드 전달하기

동작 파라미터 : 코드 블록 자체를 파라미터로 삼아서 메서드로 전달하는 것
-> 이를 통해 자주 바뀌는 요구사항에 효과적으로 대응할 수 있다.

filter 방법

1. for 과 if 를 사용해서 리스트에 담아서 리턴

       public statis List<Apple> filterGreenApples(List<Apple> inven){
       List<Apple> result = new ArrayList<>(); // 사과 재고리스트
   
           for (Apple apple : inven){
               if (GREEN.equals(apple.getColor()){ // 녹색 사과 필터링
                   result.add(apple);
               })
           }
   
           return result;
       }

• 하지만 다른 색 사과를 필터링하고 싶으면 filterColorApples 메서드를 또 만들어서 사용해야 됨.

2. Color를 파라미터로 넘김

   public statis List<Apple> filterAppleColor(List<Apple> inven, Color color){
   List<Apple> result = new ArrayList<>(); // 사과 재고리스트
       for (Apple apple : inven){
           if (apple.getColor().equals(color)){ //color인자에 따라 사과 필터링
               result.add(apple);
           }
       }
   
       return result;
   }

• 하지만, 색이 아닌 무게로 필터링을 해야하면 또 filterAppleWeight라는 메서드를 만들어서 사용해야됨.

3. 가능한 모든 속성으로 필터링

   public statis List<Apple> filterAppleColor(List<Apple> inven, Color color, int weight){
       List<Apple> result = new ArrayList<>(); // 사과 재고리스트
       for (Apple apple : inven){
           if (apple.getWeight() > (weight) || 
               apple.getColor().equals(color)){ // color, weight 인자에 따라 사과 필터링
               result.add(apple);
           }
       }
   
       return result;
   }
   
   public static void main(String[] args) {
   
       List<Apple> greenApples = filterAppleColor(inven, GREEN, 200);
       List<Apple> redApples = filterAppleColor(inven, RED, 150);
   }

• 매우 비효율적인 방법.
• 만약 다른속성이 추가되면 여러 중복된 필터 메서드를 만들거나 아니면 모든것을 처리하는 거대한 하나의 필터 메서드를 구현해야 됨.
• 하지만 동작 파라미터화로 보다 유연하게 코드를 구현할 수 있다.

4. Predicate
   필터링하고싶은 조건에 대해 논리값인 true, false 를 반환 하는 함수

//Predicate함수 선언
public interface Predicate {
  boolean test(Apple apple);
}

//무거운 사과 선택
public class HeavyWeightPredicate implements Predicate {
  @Override
  public boolean test(Apple apple) {
    return apple.getWeight() > 150;
  }		
}

//빨간 사과만 선택
public static class RedColorPredicate implements Predicate {
  @Override
  public boolean test(Apple apple) {
    return Color.RED.equals(apple.getColor());
  }		
}

public static List<Apple> filterApples(List<Apple> inventory, Predicate p) {
  List<Apple> result = new ArrayList<>();
  for(Apple apple : inventory) {
    if(p.test(apple)) {
      result.add(apple);
    }
  }
  return result;
}

public static void main(String[] args) {
  Apple[] appleList = {
              new Apple(Color.RED, 80),
              new Apple(Color.GREEN, 150),
              new Apple(Color.RED, 70),
              new Apple(Color.GREEN, 120),
              new Apple(Color.RED, 180)
          };

  System.out.println(filterApples(Arrays.asList(appleList), new RedColorPredicate()));
}

• 이런 식으로 원하는 조건의 predicate메서드를 파라미터로 넘기고 조건에 맞으면 result에 추가한다.
• 이런 동작 파라미터화를 통해 메서드가 다양한 전략(동작)을 받고 다양한 동작을 수행할 수 있다.
  드가 다양한 동작 (또는 전략)을 받아서 내부적으로 다양한 동작을 수행할 수 있다.

5. 여러개의 Predicate 클래스 간소화 : 익명 클래스

• Predicate로 유연성을 높였지만, 여전히 구현클래스에 대한 번거로운 작업이 남아있다.
• 익명클래스를 이용해서 클래스의 선언과 인스턴스화를 동시에 하면 코드의 양을 줄일 수 있다.

System.out.println(filterApples(Arrays.asList(appleList), new Predicate() {			
  @Override
  public boolean test(Apple apple) {
    return Color.RED.equals(apple.getColor());
  }
}));

이렇게 익명클래스를 사용해서 코드 양을 줄였다.
하지만 여전히 @OverRide 코드가 길다.

6. 더 간소하게! : 람다

• 람다 표현식을 이용하면 익명클래스보다 더 간결하게 구현이 가능하다.
• 또한, 필터링할 조건만 명시함으로써 코드도 명확해진다.

System.out.println(filterApples(Arrays.asList(appleList), (Apple apple) -> Color.RED.equals(apple.getColor())));

• 메소드를 람다 표현식으로 표현하면, 클래스를 작성하고 객체를 생성하지 않아도 메소드를 사용할 수 있다. -> 질문

7. 리스트 형식으로 추상화
   지금 filter 메서드는 Apple 클래스만 사용가능하다.
   따라서 다음의 코드를

List<Apple> filterApples(List<Apple> inventory, Predicate p)

이것을 제네릭을 사용해서 모든 타입에 적용가능 하도록 바꿔보면

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

public static <T> List<T> filter(List<T> list, Predicate<T> p) {
  List<T> result = new ArrayList<>();
  for(T e: list) {
    if(p.test(e)) {
      result.add(e);
    }
  }
  return result;
}

이렇게 바꾼다면 Apple클래스 뿐만이 아닌 Melon, Berry와 같은 다른 클래스에서 filter로 사용이 가능하다.

실전 예제

1. Comparator로 정렬하기

• 클라이언트의 요구사항이 달라지는 일은 빈번하다.
• 그래서 개발자에겐 변화하는 요구사항에 따라 정렬을 실행할 수 있는 코드가 필요하다.
• 코드를 파라미터화 해서 메서드의 동작을 유연하게 구현해보는 예시로 java.util.Comparator 인터페이스를 통해 설명해본다.
• Comparator를 구현해서 sort메서드의 동작을 다양하게 구현할 수 있는데, 익명클래스를 이용하는 방법도 있다.

//무게가 적은 순서로 사과를 정렬
Arrays.asList(appleList).sort(new Comparator<Apple>() {
  @Override
  public int compare(Apple o1, Apple o2) {
    return o1.getWeight().compareTo(o2.getWeight());
  }			
});

람다식으로 표현하면 다음처럼 간단하게 구현할 수 있다.

Arrays.asList(appleList).sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));

2. Runnable로 코드 블록 실행하기

• 자바 스레드를 이용하면 병렬로 코드 블록을 실행할 수 있다.
• 어떤 코드를 나중에 실행할 것인지 스레드에게 알려줄 방법이 필요했다.
• 보통 Thread 생성자에 객체만을 전달할 수 있었으므로 보통 Runnable 인터페이스를 구현한 객체를 전달하는 것이 일반적인 방법이었다.

하지만 람다로 간단하게 스레드에서 수행할 메서드를 지정할 수 있다.

//Runnable 이용
Thread t = new Thread(new Runnable() {			
  @Override
  public void run() {
    System.out.println("Hello Runnable!");

  }
});

//람다
Thread lamda_t = new Thread(() -> System.out.println("Hello Lamda!"));

3. Callable을 결과로 반환하기

• ExecutorService 인터페이스는 테스크 제출과 실행 과정의 연관성을 끊어준다.
• ExecutorService를 사용하면 테스크를 스레드 풀로 보내고 Future로 저장할 수 있다는 점이 스레드와 Runnable을 이용하는 방식과 다르다.

Callable 인터페이스 : 결과를 반환하는 테스크

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

아래 코드는 실행 서비스에 테스크를 제출해서 현재 테스크를 실행하는 스레드의 이름을 반환한다.

ExecutorService executorService =  Executors.newCachedThreadPool();

// 현재 수행하고 있는 스레드의 이름을 반환
Future<String> threadName = executorService.submit(new Callable<String>() {

  @Override
  public String call() throws Exception {
    return Thread.currentThread().getName();
  }
});

System.out.println(threadName.get());

//람다
Future<String> threadName_lamda = executorService.submit(() -> Thread.currentThread().getName());