자바에서 람다를 다루기 위한 노력

• Java

  public class Lec17Main {
      public static void main(String[] args) {
          List<Fruit> fruits = Arrays.asList(
                  new Fruit("사과", 1000),
                  new Fruit("사과", 1200),
                  new Fruit("사과", 1200),
                  new Fruit("사과", 1500),
                  new Fruit("바나나", 3000),
                  new Fruit("바나나", 3200),
                  new Fruit("바나나", 2500),
                  new Fruit("수박", 10000)
          );
  
          List<Fruit> result = Lec17Main.filterFruits(fruits, fruit -> fruit.getName().equals("사과"));
  
          result.forEach(it -> {
              System.out.println(String.format("name: %s, price: %s", it.getName(), it.getPrice()));
          });
  
          List<Fruit> result2 = Lec17Main.filterFruits2(fruits, fruit -> fruit.getPrice() >= 2000);
  
          result2.forEach(it -> {
              System.out.println(String.format("name: %s, price: %s", it.getName(), it.getPrice()));
          });
      }
  
      private static List<Fruit> filterFruits(List<Fruit> fruits, Predicate<Fruit> fruitFilter) {
          List<Fruit> results = new ArrayList<>();
          for (Fruit fruit: fruits) {
              if (fruitFilter.test(fruit)) {
                  results.add(fruit);
              }
          }
          return results;
      }
  
      private static List<Fruit> filterFruits2(List<Fruit> fruits, Predicate<Fruit> fruitFilter) {
          return fruits.stream().
                  filter(fruitFilter).
                  collect(Collectors.toList());
      }
  }
  

  • 자바에서는 JDK8부터 람다(이름이 없는 함수)가 등장했다.
  • Predicate, Consumer 등을 제공한다.
  • ‘변수 → 변수를 이용한 함수’ 형태
  • ‘(변수1, 변수2) → 변수1과 변수2를 이용한 함수' 형태
  • 간결한 스트림이 등장했다. (병렬처리에도 강점이 생김)
  • 메소드 자체를 함수의 인자로 직접 넘겨주는 것 처럼 쓸 수 있다.
  • 실제 함수를 넘기는 것처럼 보여지지만, 실제 받는 것은 미리 만들어뒀던 인터페이스를 받는것이기 때문에 직접 넘겨주는 것이 아니라 직접 넘겨주는 것 처럼 보인다.
  • 즉 자바에서는 함수를 2급시민으로 간주하는 것이다.

코틀린에서의 람다

fun main() {
    val fruits = listOf(
        Fruit("사과", 1000),
        Fruit("사과", 1200),
        Fruit("사과", 1200),
        Fruit("사과", 1500),
        Fruit("바나나", 3000),
        Fruit("바나나", 3200),
        Fruit("바나나", 2500),
        Fruit("수박", 10000)
    )

    val isApple = fun(fruit: Fruit): Boolean {
        return fruit.name == "사과"
    }

    val isApple2 = { fruit: Fruit -> fruit.name == "사과" }

    val isApple3: (Fruit) -> Boolean = fun(fruit: Fruit): Boolean {
        return fruit.name == "사과"
    }

    val isApple4: (Fruit) -> Boolean = { fruit: Fruit -> fruit.name == "사과" }

    isApple(fruits[0])
    isApple.invoke(fruits[0])

    val filterFruits = filterFruits(fruits, isApple)

    for (filterFruit in filterFruits) {
        println("name: ${filterFruit.name}, price: ${filterFruit.price}")
    }

		filterFruits(fruits, {fruit: Fruit -> fruit.name == "사과"})
		filterFruits(fruits) { fruit: Fruit -> fruit.name == "사과" }
		filterFruits(fruits) { fruit -> fruit.name == "사과" }
		filterFruits(fruits) { a -> a.name == "사과" }
		filterFruits(fruits) { it.name == "사과" }
}

private fun filterFruits(
    fruits: List<Fruit>,
    filter: (Fruit) -> Boolean
): List<Fruit> {
    val results = mutableListOf<Fruit>()
    for (fruit in fruits) {
        if (filter(fruit)) {
            results.add(fruit)
        }
    }
    return results
}

• 자바와는 근본적으로 다른 한가지가 있다.
• 코틀린에서는 함수가 그 자체로 값이 될 수 있다.
• 변수에 할당 할 수도, 파라미터로 넘길 수도 있다.
• Predicate와 같은 인터페이스를 넘기는 것이 아니라, 함수 자체를 넘겨서 사용할 수 있다.(함수를 1급시민으로 취급한다)
• 익명함수이므로 변수에 할당하지 않고 바로 함수를 작성하여 넘겨주는것도 가능하다.
• 또한 함수 호출 시 () 안에 중괄호 {}가 들어간 것을 마지막으로 빼는 형태로 사용도 가능하다.
• 그리고 필터의 타입이 Fruit이므로 익명함수를 넘겨줄 때 타입추론이 가능하기 때문에 타입을 생략해 줄 수도 있다.
• 그리고 익명함수에 들어오는 파라미터가 하나인 경우 ‘it’ 이라는 키워드를 사용할 수 있다.

Closure