개요

Java 8 버전에서 Lambda 표현을 지원한다. 아직 Java 8은 Beta 버전이다. 여러 언어 중에서 Lambda 표현을 지원하지 않는 언어로 손꼽힌다. Wikipedia에서 Anonymous Function을 참고해보면 Java 언어가 언어의 표현력에 있어서 추세를 따라가지 못하는 것이 아닐까 생각한다.

반면,

  • C#은 2007년도에 C# 3.0 버전에 LINQ 라는 대주제를 중심으로 Lambda, Anonymous Class, Extension Methods를 내놓았고,
  • C# 4.0은 2010년도에 Dynamic이라는 대주제를 중심으로 동적 프로그래밍이 가능해졌다.
  • C# 5.0은 2012년도에 비동기 라는 대주제를 중심으로 비동기 프로그래밍을 언어적으로 지원한다.

Wikipedia에서 C# 역사에 대해 더 자세히 알고 싶은 분은 'C# (programming language)' 를 참고하면 좋겠다.

Java를 이용하여 프로그래밍을 하려고 하면 정말 C#이 많이 생각난다. C#에서 한 줄짜리 문장을 Java에서는 십여 줄 넘는 경우가 많기 때문이다. 굳이 예를 들자면, 우리나라에서 유행하는 줄임말 '엄친아'를 풀어서 '엄마 친구의 아들' 로만 말해야 하는 것과 같은 느낌이랄까… 어쨌든 Java는 Java만의 매력이 있는 법. 그 매력을 찾아보는 것도 재미있겠다.

각설하고, 먼저 Java 8을 사용하여 개발할 수 있는 환경부터 간단히 살펴보자.

현재 Java 8 버전은 베타 버전이다. 현재 Java 8은 Sun사의 JDK를 칭한다. 그러므로 Oracle 사이트에서 Java 8 버전을 다운로드 받을 수 없다.

그리고 Project Lambda를 지원하는 개발 툴을 사용해야 한다. 다음의 링크의 NetBeans와 IntelliJ IDEA 12 버전에서 Project Lambda를 사용해볼 수 있다. 아래의 링크에서 다운로드 받을 수 있다.

설치와 JDK 1.8 버전의 환경 구성이 완료되었으면 Lambda 표현을 Java 에서 사용할 수 있다.

Java 8 의 Lambda 샘플 예제 간단한 예제만 소개하겠다.

(Java에서 권장하는 네이밍이나 코드 구현 방식에 맞지 않는 부분이 있더라도 양해 바란다.) 간단한 더하기 계산을 Lambda 표현으로 작성하면 다음과 같다. 



위의 코드로 말미암아 Lambda 표현은 (arguments) -> { … } 로 표현할 수 있겠다.

간단하게 Thread를 돌리는 코드를 Lambda 표현식으로 작성해보자. 




다음은 ExecutorService를 Lambda 표현으로 작성하였다. 





Java의 Lambda 이야기가 나온 김에 어떻게 Lambda 표현으로 발전하였는지도 짤막하게 보자.

원래 이런 코드가 있었다. Runnable Interface를 구현하는 코드이다. 




또는 Java의 Local Class를 이용할 수 있다. Local Class는 메서드 구현부에서 Class를 선언하여 이를 인스턴스화 할 수 있다.

위의 Runnable Interface를 구현한 코드를 Anonymous Class(익명 클래스)로 표현할 수 있게 되었다. 그래서 아래의 예제와 같이 Interface를 구현하는 Class를 만들지 않아도 된다. 



위 Anonymous Class를 Lambda 표현으로 작성하면 더 간결하게 표현할 수 있다. 


단, Java 8의 Lambda 표현에 제약이 있다.

그리고 Project Lambda를 소개하는 페이지의 Functional Interfaces 에서 제약에 대한 설명이 있다. 하지만 이는 근본적으로 Java에서는 C/C++의 Pointer를 표현할 방법이 없는 이유이다. 그러므로 함수를 가리키는 Pointer도 있을 수 없다. 반면, C#에서는 함수포인터를 표현하기 위해 Delegate(대리자)를 지원한다. C#에서는 함수포인터를 안전하게 다룰 수 있다.

그래서 Java에서는 함수포인터를 표현하기 위해서 Listener 형태의 패턴을 주로 사용한다. 다른 말로 Observer 패턴이라고 부른다. Java의 Thread가 대표적이다. Java의 Thread는 Runnable을 인자로 받는 생성자가 있다. 위의 코드에서도 볼 수 있듯이 Runnable은 void run() 메서드만 달랑 가지고 있는 Interface이다. Java의 Thread는 이 Runnable Interface만 알고 있으면 되고, Runnable Interface를 구현하는 인스턴스를 Thread에게 넘겨주면 된다.

반면, C#의 Thread는 Delegate(대리자-안전한 함수 포인터)를 이용하여 Thread를 실행한다. C# 컴파일러는 Delegate를 결국 Class 로 취급한다. 이로 말미암아 Java와 C#에서 포인터라는 것은 언어적으로는 전혀 메커니즘으로 작동하지만 런타임 입장에서는 유사한 메커니즘으로 동작한다는 것을 알 수 있다. 하지만 Java에서 함수포인터를 흉내를 낼 수 있는 방법은 있다. 키/쌍의 컬렉션을 이용하여 참조를 전달하는 방법이다. 아래는 간단한 예제 코드이다. 



어찌되었든 결국, Java의 Lambda는 Interface를 이용하여 Lambda 함수를 만듦으로써 Interface의 함수가 단 1개만 있어야 Lambda 표현을 할 수 있는 제약이 생겼다. Interface를 이용하여 Lambda를 표현한다고 함은 내부적으로 Proxy 객체를 생성하여 그 안에 Lambda 표현을 메서드로 만든다.

아래의 익명 클래스를 보자. 아래의 runnable 로컬 변수를 리플랙션을 이용하여 getMethods() 의 목록이다. 



아래의 Lambda 표현을 보자. 마찬가지로 runnable 로컬 변수를 리플랙션을 이용하여 getMethods() 의 목록이다. 


이를 통해 Java의 Lambda 표현식은 내부적으로 Proxy 클래스가 생성됨이 확인되었다. 그런데 이 Proxy 클래스가 언제 생성이 될까? 컴파일 타임에 생성이 될까, 아니면 런타임에 생성이 될까?

이를 JD-GUI 도구를 이용하여 Decompile 결과를 확인하려고 하였으나, Java 1.8.0 버전에 대해서 JD-GUI 가 올바르게 인식을 하지 못해 전혀 class 파일을 전혀 읽을 수 없다. 대신 .class 파일을 Text Editor 로 열어서 대략적인 내용을 확인할 수 있는데, Text Editor 에서는 Lambda 표현으로 구현된 Proxy Class 를 찾을 수 없었다. 따라서 Lambda 표현은 런타임에 구현 객체 Proxy 가 생성된다는 것을 알 수 있다. (다만, 확신은 못하겠다.)

한가지, Java 8의 Lambda 표현의 다른 점이라면 Lambda 표현의 Proxy 객체는 java.lang.invoke.MagicLambdaImpl 클래스를 상속한다는 점이다. 앞서 얘기했듯이 JD-GUI 도구가 Java JRE 1.8.0 의 rt.jar 파일을 상위 호환성이 아직 지원되지 않아 구현 내용을 알 수는 없었다. 이는 좀 더 Java 8의 Release 시기가 다가오기를 기다려야 할 것 같다. 



결론은 Java 8의 Lambda 표현을 하기 위해서는 Interface 의 구현 함수는 반드시 1개여야 한다는 점이다.

Posted by 땡초 POWERUMC

댓글을 달아 주세요

  1. 짜두 2013.01.17 08:59 Address Modify/Delete Reply

    이제 베타버전이니 좀더 발전해야 겠네요. 굉장히 빠른 속도로 발전해나가지 않을까하는 생각이 드네요.ㅎ

[.NET/C# 3.0] - 람다식(Lambda Expressions) 을 이용한 확장 메서드(Extension Methods) 만들기 [1]
[.NET/C# 3.0] - 람다식(Lambda Expressions) 을 이용한 확장 메서드(Extension Methods) 만들기 [2]
 
 
 
지난 아티클에서 우리는 List<> 컬렉션에 특정 요소를 탐색하기 위해 delegate 와, 익명 메서드, 람다식을 이용한 방법을 알아보았다.
 
List<> 컬렉션의 Find와 FindAll 메서드는 List<> 클래스가 제공하는 메서드지만, 이와 비슷한 확장 메서드를 손수 구현해 보도록 할 것이다.
 
 
이번에도 다음의 List<> 컬렉션의 데이터를 가지고 예제를 만들어 볼 것이다.
 
List<int> arr = new List<int>();
arr.Add(1);
arr.Add(2);
arr.Add(3);
arr.Add(4);
 
지난 강좌에서 보듯 다음과 같이 List<> 클래스의 Find 메서드를 이용하여 특정 요소를 탐색한다.
 
int result = arr.Find(o => o == 2);
Console.WriteLine(result);
 
 
 
List<Int>.Find 메서드를 확장 메서드로 구현
 
확장 메서드를 구현하기 위해 MyExtension 이라는 클래스를 만들고 UmcFind 라는 메서드를 만들자.
 
static class MyExtension
{
           public static int UmcFind(this IEnumerable<int> arr, Predicate<int> p)
           {
                     List<int> ret = new List<int>();
                     foreach (var v in arr)
                     {
                                if (p(v))
                                          return v;
                     }
 
                     return 0;
           }
}
 
위 확장 메서드는 다음과 같이 호출이 가능하다.
 
int result = arr.UmcFind(o => o == 2);
Console.WriteLine(result);
 
 
Public static int UmcFind(this IEnumerable<int> arr, Predicate<int> p)
 
의 선언을 보자.
 
인자값에 오는 this 는 확장메서드를 지원할 원본 객체의 타입이다. 즉, 우리는 List<int> 에 대한 객체에만 확장 메서드를 지원하게 된다.
 
Predicate<Int> p
 
는 .NET Framework 에서 선언된 bool 을 리턴하는 델리게이트이다.
 
즉, o => o == 2 람다식의 “ o == 2 “ 의 구현부는 Predicate 델리게이트에게 위임된 것이다.
때문에,
 
if( p( v ) )
 
와 같이 Predicate 의 리턴이 bool 이므로 람다식의 조건을 True/False 로 리턴 받을 수 있다.
 
 
 
List<Int>.FindAll 메서드를 확장 메서드로 구현
 
아래와 같이 사용되는 List<int>.FindAll 메서드를 확장 메서드로 구현해 보자.
 
List<int> result = arr.FindAll(o => o >= 2 && o <= 3);
result.ForEach(o => Console.WriteLine(o));
 
 
이번에는 .NET Framework 가 제공하는 델리게이트를 사용하지 않고, 직접 델리게이트를 선언해 볼 것이다.
 
delegate TResult FindAllHandler<T, TResult>(T t);
 
FindAll 확장 메서드를 구현하기 위해 제네릭 델리게이트를 선언해 보았다.
첫번째 T 는 받을 인자 타입이고, 두번째 TResult 는 리턴 타입이 된다.
 
그럼 UmcFindAll 이라는 확장 메서드를 만들어 보자.
 
static class MyExtension
{
           public static List<int> UmcFindAll(
            this IEnumerable<int> arr, FindAllHandler<int,bool> p)
           {
                     List<int> result = new List<int>();
 
                     foreach (var v in arr)
                     {
                                if( p(v) )
                                          result.Add( v );
                     }
                     return result;
           }
}
 
위의 확장 메서드는 다음 처럼 사용이 가능하다.
 
List<int> list = arr.UmcFindAll(o => o >= 2 && o <= 3);
list.ForEach(o => Console.WriteLine(o));
 
 
 
보시는 바와 같이 List<> 클래스가 제공하는 FindAll 메서드와 동일한 기능을 하는 확장 메서드를 만들어보았다.
 
UmcFindAll 확장 메서드는 제네릭 델리게이트를 선언하여 예제를 만들어 보았지만, UmcFind 확장메서드를 유심히 본 독자라면 보는데 큰 어려움이 없을 것 같다.
 
 
이것으로. 람다식의 간략한 이용 방법과 람다식을 사용하는 확장 메서드에 대해서 알아 보았다.
Posted by 땡초 POWERUMC

댓글을 달아 주세요

  1. 상준 2011.03.24 14:17 Address Modify/Delete Reply

    글 너무 너무 잘봤습니다.
    하지만 이해하기 너무 힘드네요...
    실례지만 해당 소스코드도 있었으면..
    더좋은 글이 되지 안을까 생각합니다..

[.NET/C# 3.0] - 람다식(Lambda Expressions) 을 이용한 확장 메서드(Extension Methods) 만들기 [1]
[.NET/C# 3.0] - 람다식(Lambda Expressions) 을 이용한 확장 메서드(Extension Methods) 만들기 [2]



C# 3.0 에서 LINQ 를 위해 많은 언어적 개념이 도입되었다.
확장 메서드(Extension Methods)와 Lambda Expression 등이 바로 그것이다.
그중 Lambda Expression(이하 람다식) 은 Ruby 에서 먼저 나왔다고 하지만, C# 3.0 에서의 람다식은 LINQ 와 확장 메서드와 굉장히 사슬처럼 엮여 있는 듯한 모습이다.
 
람다식은 대리자(Delegate)와 제네릭 메서드의 복잡한 식을 간결하게 줄여줄 수 있다.
 
=>
 
연산자를 이용하여, 익명 메서드(Anonymous Method) 의 여러줄의 코드를 단 한줄의 코드로 줄여줄 수 가 있다.
 
좀더 자세한 설명히 필요하다면 다음을 참고 하도록 하자.
http://msdn.microsoft.com/msdnmag/issues/07/09/BasicInstincts/Default.aspx?loc=ko
 
 
우리가 사용할 예제는 다음의 List<int> 컬렉션을 사용할 것이다.
 

List<int> arr = new List<int>();
arr.Add(1);
arr.Add(2);
arr.Add(3);
arr.Add(4);

 
 
List<> 컬렉션은 Find 라는 메서드를 제공한다. ( 확장 메서드가 아님 )
이 메서드는 컬렉션의 특정 요소를 찾기 위해 사용되어 지는데, C# 이 제공하는 Predicate<> 델리게이트를 통해 True/False 를 반환하는 델리게이트이다.
 
그럼 List<> 컬렉션의 특정 요소를 찾기 위해 다음과 같이 사용된다.
 

static void Main(string[] args)
{
           List<int> arr = new List<int>();
           arr.Add(1);
           arr.Add(2);
           arr.Add(3);
           arr.Add(4);
 
           Predicate<int> p = new Predicate<int>(Compare);
           int result = arr.Find(p);
           Console.WriteLine(result);
}
static bool Compare(int i)
{
           return i == 2;
}

 
 
Predicate<int> p = new Predicate<int>(Compare);
 
Predicate<> 대리자는 Compare 메서드에게 일거리를 할당한 것을 볼 수 있다.
 
그럼, 가상 메서드를 이용하여 코드양을 줄여 보도록 하자.
 

int result = arr.Find(new Predicate<int>(
                                delegate(int i)
                                {
                                          return i == 2;
                                }
                     ));
Console.WriteLine(result);

 
 
위와 같이 당연히 결과는 “2” 가 나타났다.
델리게이트를 통해 i==2 라는 요소를 찾기위해 int 인자와 bool 을 리턴하는 메서드를 만들어야 하지만, 위의 delegate 키워드의 구문은 가상 메서드를 만들게 됨으로써 코드양이 많이 줄어 들게 되었다.
 
하지만, 람다식을 이용하여 더 줄여보도록 하자.
 

Console.WriteLine(arr.Find(o => o == 2));

 
 
위 7개 라인을 단 한줄로 해결하였다.

 
사실 이 구문이 선듯 이해가 가지 않는 필자는 무진장 머리를 굴려보았다.
잘 이해를 하기 위해 람다식을 마치 메서드가 있는 구문이라고 머리속으로 상상해보기 바란다.
 
 
 
=> 연산자를 기준으로 왼쪽은 넘길 인자값이 되는 것이고, 오른쪽은 내용이 되는 것이다.
 
그래도 잘 이해가 안된다면 마치 메서드가 존재한다는 상상 훈련을 해보면 그리 오래 걸리지 않고 쉽게 이해가 될 것 같다.
다음 2편에서는 제네릭 대리자를 통해 람다식이 가능한 확장 메서드를 만들어 보도록 하자
Posted by 땡초 POWERUMC

댓글을 달아 주세요

  1. 지송 2010.06.17 12:57 Address Modify/Delete Reply

    람다식 찾다왔는데 역시 이해가 쉽게 써놓으셨네요.

    좋은 하루 되세요 !