☌

보다 쉽게 사용가능한 WeakReference!

개발이야기/오픈소스 N series 2017. 1. 26. 01:25

해당 포스팅에서 언급된 내용은 Ndroid 에서 제공합니다.

https://github.com/skaengus2012/Ndroid


안드로이드 개발을 진행하다보면 Activity 의 생명주기와 스레드 사용지점이 맞지 않아 누수가 되곤 합니다. 그러한 이유로 WeakReference 를 사용하란 이야기가 많이 나오곤 합니다.


보통 Activity 인스턴스를 약한참조 관계로 가지고 있습니다. 그리고 해당 인스턴스의 메소드를 사용하기 위해 우린 객체를 꺼내서 다음과 같이 사용합니다.


1
2
3
4
5
6
MyActivity activity = easyWeakReference.get();
        
if (activity != null) {
    // 메모리가 해제되어 더이상 존재하지 않는 객체인지 확인할 필요 존재!
    activity.func1();
}
cs


심플하게 사용할 수 있지만, 


프로그램의 덩치가 커지고 WeakReference 를 사용할 일이 많아진다면,


별 거 아닌 것 같은 저 null check 는 매우 귀찮고 중복작업일 수 있습니다.


이 문제는 아래의 WeakReference 의 상속체를 제작함으로 간단하게 해결할 수 있습니다. 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
public class NxWeakReference<T> extends WeakReference<T> {
 
    /**
     * 단순한 상속에 대한 생성자 제작
     * @param referent
     */
    public NxWeakReference(T referent) {
        super(referent);
    }
 
    /**
     * 단순한 상속에 대한 생성자 제작
     * @param referent
     * @param q
     */
    public NxWeakReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
 
    /**
     * 약한 참조 속 실제 객체의 사용
     * @param weakReferenceConsumer
     */
    public void run(IWeakReferenceConsumer<T> weakReferenceConsumer) {
        T t = this.get();
 
        if (t != null) {
            weakReferenceConsumer.accept(t);
        }
    }
 
    /**
     * 약한 참조 속 실제 객체의 사용
     *
     * <pre>
     *     call back 의 개념 사용
     * </pre>
     *
     * @param weakReferenceFunction
     */
    public Object call(IWeakReferenceFunction<T> weakReferenceFunction) {
        Object result = null;
 
        T t = this.get();
 
        if (t != null) {
            result = weakReferenceFunction.accept(t);
        }
 
        return result;
    }
 
    /**
     * 약한 참조 속 실제 객체의 사용
     *
     * <pre>
     *      call back 개념 사용
     *      defaultValue 사용
     * </pre>
     *
     * @param weakReferenceFunction
     * @param defaultValue
     * @return
     */
    public Object call(IWeakReferenceFunction<T> weakReferenceFunction, Object defaultValue) {
        final Object result = call(weakReferenceFunction);
 
        if (result == null) {
            return defaultValue;
        } else {
            return result;
        }
    }
 
    /**
     * WeakReference 의 내부객체를 사용하기 위한 Consumer 인터페이스
     * @param <T>
     */
    @FunctionalInterface
    public interface IWeakReferenceConsumer<T> {
        void accept(T t);
    }
 
    /**
     * WeakReference 의 내부객체를 사용하기 위한 Function 인터페이스
     * @param <T>
     */
    @FunctionalInterface
    public interface IWeakReferenceFunction<T> {
        Object accept(T t);
    }
}
 
cs


상속 후 새로 제작된 accept 는 위의 null 체크를 수행하도록 하며, 실제 비지니스 로직은 함수형 인터페이스로 동작파라미터화 시켰습니다. 


동작 파라미터화가 무엇인지 궁금하다면, 이곳으로 이동!!


2016/07/25 - [개발이야기/함수형 프로그래밍] - 동작 파라미터화와 함수형 프로그래밍 (1)


이제 비지니스 로직은 다음과 같이 단순화하여 개발할 수 있습니다.


1
easyWeakReference.run(MyActivity::func1);
cs

함수형 프로그래밍을 조금만 알면 쉽게 작업은 단순화시킬 수 있습니다. 




반응형

'개발이야기 > 오픈소스 N series ' 카테고리의 다른 글

예외처리를 간소화하여, 코드를 이쁘게 해보자!  (9) 2017.05.10
Calendar 를 조금 더 쉽게 써보자, TimeUtil & TimeBuilder  (0) 2017.03.26
RxJava2 의 Maybe를 조금 더 적극적으로 써보자! MaybeUtil!  (2) 2017.03.16
안드로이드 람다 조합 (RxJava2 호환)  (0) 2017.03.08
조금 더 구체적인 안드로이드 개발 패턴화  (2) 2017.01.30
Posted by N'
,

Stream API 활용편5 (숫자형 스트림, 스트림 생산)

개발이야기/함수형 프로그래밍2017. 1. 25. 02:22

현재 공부하고 있는 도서의 Stream API 에 대한 자세한 설명이 나와 있어서, 같은 주제로 계속 블로깅을 하고 있습니다. 


하지만 대략적인 부분이 끝이 난 것 같습니다. Stream API 소개는 이번 포스팅이 마지막입니다.

지난 Stream API 가 궁금하다면, 하단 글들을 참고해주세요. :-)


2016/08/26 - [개발이야기/함수형 프로그래밍] - Stream API 활용편1 (필터와 슬라이싱)


2016/08/27 - [개발이야기/함수형 프로그래밍] - Stream API 활용편2 (매핑)


2017/01/18 - [개발이야기/함수형 프로그래밍] - Stream API 활용편3 (검색과 매칭)


2017/01/23 - [개발이야기/함수형 프로그래밍] - Stream API 활용편4 (리듀싱)


오늘 포스팅은 보통 전공 과목에서 흔히 말하는 기타 기능에 대해 알아보려고 합니다. 그러나 유용할 수 있죠? :-)


1. 숫자형 스트림으로 변환


람다를 포스팅할 때도 있었지만, 스트림 역시 원시타입의 스트림을 지원합니다. 보다 더 정확히 말하면, 숫자들에 대한 스트림을 지원하며 이 기본형 특화 스트림들은 sum, max, min 등 자주 사용하는 리듀싱 메소드를 제공해줍니다.


숫자 스트림을 사용하기 위해서는 map 의 파생 메소드인 mapToInt, mapToDouble, mapToLong 등의 메소드를 사용해야 합니다.


예제부터 한번 봐볼까요?


1
2
3
4
5
6
7
8
9
List<Integer> numberList = Arrays.asList(1,2,3,4,5,6);
    
System.out.println(
        numberList.
            stream().
            mapToInt(Integer::intValue).
            sum());
 
// 출력 21
cs


간단한 Integer Collection 객체의 stream 에서 int value 의 stream 얻기 위해 mapToInt 메소드를 사용하였으며(언박싱), 리듀스 메소드 중 하나인 sum 을 사용하였습니다.


추가적으로 또다른 리듀싱 메소드인 max나 min 은 Optional 상태로 데이터가 제공됩니다. 컬렉션이 비어있는 상태에서 max 나 min 의 값이 무조건 존재한다는 것을 보장할 수 없기 때문이죠.



2. 숫자 범위 스트림


JAVA8 에서는 숫자형스트림에서 특정 범위안의 숫자 집합을 출력해주는 정적메소드인 range 와 rangeClosed 를 제공해줍니다. 두 메소드 모두 범위에 대한 인수를 받으며, 차이는 시작값과 종료값이 결과에 포함하는 여부입니다. (range 의 경우 결과에 포함되지 않습니다.)


사용예제는 다음과 같습니다. 아래 예제는 숫자 Stream 을 이용하여, 피타고라스의 수를 구하는 쿼리입니다.


1
2
3
4
5
6
7
IntStream.rangeClosed(1,100).
        boxed().
        flatMap(a -> IntStream.
                        rangeClosed(a, 100).
                        mapToObj(b -> new int[]{a, b, (int) Math.sqrt(a *a + b * b)})).
        filter(v -> v[2]%1 == 0).
        forEach(v -> System.out.println(v[0] + " " + v[1] + " " + v[2]));
cs


flatMap 을 통해, 두 개의 숫자 스트림을 엮었습니다. 첫번째 범위에서는 Stream 연산의 결과를 객체로 받기 위해 boxed 메소드를 사용하였습니다. boxed 객체를 사용하지 않으면, 오직 중간연산 결과로 숫자타입의 스트림밖에 생산할 수 없습니다. (왜냐하면 IntStream 은 숫자 스트림이기 때문이죠. ㅡㅡ^)



3. 스트림 만들기


컬렉션이나 배열은 다음과 같이 임의의 값으로 데이터를 만들 수 있습니다.


1
2
String[] dataArray = new String[]{"남두현", "윤석진", "성지윤", "오진명"}; 
List<String> dataList = Arrays.asList(dataArray);
cs


스트림 역시 임의의 값으로 스트림 만들기가 가능합니다. 꼭 컬렉션 클래스의 stream 키워드를 쓸 필요는 없는 것이죠. ㅡㅡ^


1
2
3
4
String[] dataArray = new String[]{"남두현", "윤석진", "성지윤", "오진명"}; 
        
Stream<String> ofStream = Stream.of("남두현", "윤석진", "성지윤", "오진명");
Stream<String> arrayStream = Arrays.stream(dataArray);
cs



4. 고정되지 않은 크기의 스트림 만들기


여태까지 Stream은 고정된 크기의 컬렉션을 통해서 만들곤 했습니다. 그러나 특정 Function, Supplier 타입의 메소드 레퍼런스 (람다 포함) 를 통해 무한한 Stream 을 만들 수 있습니다.


1
2
3
4
5
// iterate 는 Function type 람다를 사용 
Stream.iterate(0, n -> n + 2).forEach(System.out::println);
        
// generate 는 Supplier type 메소드 레퍼런스 사용
Stream.generate(Math::random).forEach(System.out::println);    
cs


만들 수 있는 key-word 메소드는 iterate 와 generate 로 보통 limit 로 제한을 두어 사용하곤 합니다. 제한을 두지 않은 스트림을 언바운드 스트림(Unbounded Stream) 이라 하며, 특정 로직에서 무한한 결과 때문에 제대로된 결과를 얻을 수 없을 지도 모릅니다. 

(그러나 위 예제 에서는 무한한 숫자가 출력이 될 것입니다. 컬렉션과 달리 Stream 은 즉시 생산을 하는 것이 특징이기 때문이죠. ㅡㅡ^)


이 것으로 Stream API 활용과 관련된 주제는 끝났습니다.


다음 포스팅 부터는 Stream 을 통한 데이터 수집과 관련된 주제로 진행을 하게 될 것 같습니다. 

(스포일러를 하자면, 언제나 최종 연산을 구할 때 사용했던 Collector 와 관련된 이야기 입니다. ^^)



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기


반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

병렬처리(1) - Stream API 를 이용해 간단히 병렬화 하기.  (0) 2017.02.15
Collectors! 데이터를 수집해보자.  (0) 2017.02.02
Stream API 활용편4 (리듀싱)  (0) 2017.01.23
Stream API 활용편3 (검색과 매칭)  (0) 2017.01.18
Stream API 활용편2 (매핑)  (0) 2016.08.27
Posted by N'
,

Stream API 활용편4 (리듀싱)

개발이야기/함수형 프로그래밍2017. 1. 23. 23:21

 지금까지는 Stream API 의 최종 연산에서 여러 종류의 값 (Boolean, filter 된 리스트, void 연산) 을 반환을 함을 알 수 있었습니다. 여러 중간 연산을 pipe 처럼 묶어서 사용하고, 그 결과를 취함으로 여러 로직의 이점을 많이 챙길 수 있었습니다.


오늘의 포스팅 주제는 조금 더 복잡한 질의를 표현할 수 있는 리듀싱(reducing)에 대해 알아보려고 합니다. 예를 들어, 컬렉션 내부에 대해 총합을 구한다거나 최대값, 최소값을 구하는 연산이 대표적이라고 할 수 있습니다. ㅡㅡ^


 간단한 예제 부터 한번 봐보도록 할까요? 아래 코드는 컬렉션 내부의 값 중, 짝수 만을 덧셈하는 연산입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
List<Integer> numberList = Arrays.asList(5, 10, 3, 6, 92);
        
int sum = 0;
        
for (Integer number : numberList) {
    if (number % 2 == 0) {
        sum += number;
    }
}
 
System.out.println("총 합 : " + sum);
 
// 총 합 : 108
cs


 이 간단한 코드는 Stream 연산을 통해 더욱 간단해질 수 있습니다. 약간의 중간연산과 리듀싱을 통해 처리할 수 있습니다.


1
2
3
4
5
6
7
8
9
10
List<Integer> numberList = Arrays.asList(5, 10, 3, 6, 92);
 
System.out.println("총 합 : " + 
            numberList.
                stream().
                filter(n -> n % 2 == 0).
                reduce(0, (a, b) -> a + b)
            );
 
//총 합 : 108
cs


 filter 를 통해 짝수만 추출했으며, reduce 를 이용해 덧셈의 결과를 구했습니다.


위의 예제에서 사용한 reduce 는 초기 값을 0 을 했음을 알 수 있습니다. 물론, 초기값이 없는 연산을 수행할 수 있습니다. 이 때 결과는 Optional 객체로 나타나게 되며 해당 객체를 이용해 값이 있을 때만 처리하는 기능 등을 수행할 수 있습니다.


리듀싱의 응용은 다양하게 할 수 있습니다. 예를들어 특정 객체에 대한 컬렉션 중, 한 필드에 대한 합은 다음과 같이 구할 수 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
 * Test 를 위한  VO
 * 
 * @author namduhyeon
 *
 */
class TestVo {
    private String name;
    private Integer value;
    
    public TestVo (String name, Integer value) {
        this.name = name;
        this.value = value;
    }
 
    public String getName() {
        return name;
    }
 
    public Integer getValue() {
        return value;
    }
}
 
List<TestVo> numberList = Arrays.asList(
                new TestVo("Doohyun Nam",7)
                , new TestVo("Ford Mill",9)
                , new TestVo("Hwang",2));
        
numberList.stream().
    map(v -> v.getValue()).
    reduce((v1, v2) -> v1 + v2).
    ifPresent(System.out::println);
 
// 18
cs


특정 필드를 추출하기 위해 map 을 사용하였으며, 이 Stream 을 통해 합을 구할 수 있었습니다. 


이러한 map 과 reduce 를 이용하여, 데이터를 가공하는 패턴을 map-reduce 패턴이라 하며 웹 검색 엔진 등에서 많이 사용하는 것을 볼 수 있습니다.


그 이유는 언제나 Stream API 에서 쉽게 볼 수 있는 병렬성이라는 특징 덕분입니다. 예를 들어 특정 컬렉션의 합을 병렬적으로 구하기 위해서는 임계영역간 스레드의 경쟁 비용이 발생하기 마련이지만, 리듀스 내부의 내부반복은 개발자에게는 추상화되어 제공됩니다. (분할하여 결과를 구하고 머징하는 과정이 아닐지...) 


하지만, 모든 기능이 만병통치약일 수는 없습니다. ㅡㅡ^ 

병렬스트림으로 리듀싱 결과를 일반 스트림과 동일하게 얻기 위해서는 연산이 어떤 순서로 연산되어도 결과가 보장되는 구조이며, 람다 내부 인스턴스는 변경되어서는 안되는 구조이어야 합니다. 즉 각 트랜잭션 중 병렬구조로 처리가 가능한 부분만 사용이 가능함을 알 수 있습니다.


복잡한 데이터의 질의를 쉽게 표현할 수 있는 리듀싱에 대해 알아보았습니다. 생각보다 자주 접해보면, 금방 눈에 들어오지 않을까 생각이 듭니다. 


점점 함수형 프로그래밍의 장점이 눈에 들어오지 않으시나요? :-) 


자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기




반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Collectors! 데이터를 수집해보자.  (0) 2017.02.02
Stream API 활용편5 (숫자형 스트림, 스트림 생산)  (0) 2017.01.25
Stream API 활용편3 (검색과 매칭)  (0) 2017.01.18
Stream API 활용편2 (매핑)  (0) 2016.08.27
Stream API 활용편1 (필터와 슬라이싱)  (0) 2016.08.26
Posted by N'
,

Stream API 활용편3 (검색과 매칭)

개발이야기/함수형 프로그래밍2017. 1. 18. 08:58

지난 포스트에 이어서, 계속 Stream API에 대한 포스팅을 하고 있습니다.


지난 포스팅에서는 각 컨테이너를 매핑하여, 원하는 형태의 객체로 출력을 할 수 있는 방법을 소개했었습니다. 

마치 SQL 처럼 특정 필드만을 추출한다던가, 두 개 이상의 컨테이너를 JOIN 할 수도 있었죠.


해당 포스팅은 이 곳에서 확인!! 


2016/08/27 - [개발이야기/함수형 프로그래밍] - Stream API 활용편2 (매핑)


오늘은 특정 속성이 데이터 집합에 있는지, 있다면 해당 객체를 추출할 수 있는 다양한 유틸 메소드를 살펴볼까 합니다.


예를 들어, 우리는 이러한 작업을 많이 하곤 합니다.


아래 로직은 특정 숫자 컬렉션에서 5의 배수가 있는지 확인하는 로직입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
List<Integer> sampleList = Arrays.asList(5,10,12,38);
        
Boolean isHave = false;
for (Integer number : sampleList) {
    if (number % 5 == 0) {        
        // 5의 배수인 데이터가 있는지 확인
        isHave = true;
        break;
    }
}
        
System.out.println("5의 배수가 존재  : " + isHave);
 
// 출력 : 5의 배수가 존재  : true
cs


루프를 돌면서, 출력할 컬렉션 객체에 if 조건을 사용하여 여부를 업데이트하려 하고 있습니다.


해당 로직은 다음과 같이 수정될 수 있습니다.



1. Predicate 가 적어도 한 요소와 일치하는지 확인 (anyMatch)


anyMatch 유틸 메소드로 다음과 같은 로직을 구할 수 있습니다.


1
2
3
4
5
List<Integer> sampleList = Arrays.asList(5,10,12,38);
        
System.out.println("5의 배수가 존재  : " + sampleList.stream().anyMatch(n -> n % 5 == 0));
 
// 출력 : 5의 배수가 존재  : true
cs


단순히 predicate 형태로 컬렉션 제네릭 객체의 조건만 명시해주면 조금 더 간소화된 코드를 구현할 수 있습니다.


2. Predicate 를 이용한 기타 확인 (allMatch, noneMatch)


Predicate 를 이용하여 컬렉션의 모든 요소가 일치하는지를 확인하려면, allMatch 메소드를 사용할 수 있습니다. 또한 반대로 일치하는 요소가 없는지를 확인하는 기능 역시도 noneMatch 메소드를 사용함으로써 간단하게 구현할 수 있습니다.


1
2
3
4
5
6
7
8
9
List<Integer> sampleList = Arrays.asList(5,10,15,40);
        
System.out.println("모든 요소가 5의 배수인가? : " + sampleList.stream().allMatch(n -> n%5 == 0));
System.out.println("5의 배수는 없는가? : " + sampleList.stream().noneMatch(n -> n % 5 == 0));
 
// 출력
// 모든 요소가 5의 배수인가? : true
// 5의 배수는 없는가? : false
 
cs


3. 요소 검색


Stream API 를 사용하면 쉽게 한 요소에 접근할 수 있습니다. 일련의 중간 연산(filter, distinct 등)을 수행한 후 findAny, findFirst 등의 최종연산 메소드로 조건에 맞는 한 요소를 선택할 수 있습니다. 예제를 한번 볼까요? 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
List<Integer> sampleList = Arrays.asList(17,19,28,37,16);
        
sampleList.
    stream().
    filter(n -> n % 2 == 0).
    findAny().
    ifPresent(n -> System.out.println("2의 배소의 요소 찾기 : " + n));
        
sampleList.
    stream().
    filter(n -> n % 2 == 0).
    findFirst().
    ifPresent(n -> System.out.println("2의 배소의 첫번째 요소 찾기 : " + n));
 
// 출력
// 2의 배소의 요소 찾기 : 28
// 2의 배소의 첫번째 요소 찾기 : 28
cs


두 메소드의 내용을 살펴보면, 동일함을 알 수 있습니다. 왜냐하면, 쇼트서킷 검사(보통 Boolean 연산 특정 조건에 의해 검사결과가 정해지면 추 후 연산은 안하는 행위)를 통해 결과를 찾은 뒤 즉시 실행을 하기 때문이죠.


그렇다면 왜 굳이 메소드를 두 개로 둔 이유가 무엇일까요?


그 이유는 공짜로 얻을 수 있는 병렬성 이 후 후처리 때문입니다. Collection 클래스에서 Stream 추출 시, parallelStream 을 통해 병렬 처리를 쉽게 수행할 수 있습니다. 그러나 병렬처리를 수행 시 컬렉션의 순서가 보장이 되지 않습니다! ㅡㅡ^


즉 병렬처리를 통해 데이터 연산을 수행하였다면, 명시적으로 첫 번째 요소를 찾기 위해 findFirst 를 사용하여야만 합니다! 


아래 예제를 통해 결과를 확인해볼까요? 아래 예제는 병렬처리를 했음에도 findFirst 사용 시, 첫 번째 요소찾기를 보장하고 있음을 보여주고 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
List<Integer> sampleList = Arrays.asList(17,19,28,37,16);
        
sampleList.
    parallelStream().
    filter(n -> n % 2 == 0).
    findAny().
    ifPresent(n -> System.out.println("2의 배소의 요소 찾기 : " + n));
        
sampleList.
    parallelStream().
    filter(n -> n % 2 == 0).
    findFirst().
    ifPresent(n -> System.out.println("2의 배소의 첫번째 요소 찾기 : " + n));
 
// 출력
// 2의 배소의 요소 찾기 : 16
// 2의 배소의 첫번째 요소 찾기 : 28

cs



마지막으로 생각해봐야할 부분은 요소 검사 메소드 활용 시, 결과가 항상 있다는 것을 보장하지 않는다는 점입니다. 보통 이럴 때 기존 자바에서는 null 로써, 데이터를 처리했지만 JAVA8 부터 많은 함수형 프로그래밍에서 볼 수 있는 Optional 의 개념이 생겼습니다. 


Optional 은 값의 존재나 부재 여부를 표현하는 컨테이너 클래스로, 예제에서 사용한 ifPresent 는 값이 존재할 때만 실행을 명령하는 메소드 입니다. (Optional 은 추 후 따로 포스팅을 한 후 연결을 시켜두겠습니다. ㅡㅡ^)



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기



반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API 활용편5 (숫자형 스트림, 스트림 생산)  (0) 2017.01.25
Stream API 활용편4 (리듀싱)  (0) 2017.01.23
Stream API 활용편2 (매핑)  (0) 2016.08.27
Stream API 활용편1 (필터와 슬라이싱)  (0) 2016.08.26
Stream과 Collection 차이  (0) 2016.08.04
Posted by N'
,

Stream API 활용편2 (매핑)

개발이야기/함수형 프로그래밍2016. 8. 27. 10:57

지난 포스트에 이어서, 계속 Stream API에 대한 포스팅을 하고 있습니다. 


Stream API를 활용하여, 컨테이너(Collection)에서 복잡하고 다양한 조건을 질의형태로 구현할 수 있다는 것을 배웠습니다. 방어코드 없이 말이죠!! 


지난 포스팅은 이곳에서 확인! 


2016/08/26 - [개발이야기/함수형 프로그래밍] - Stream API 활용편1 (필터와 슬라이싱)


이러한 질의와 같은 방법은 SQL과 비슷해서 우리가 원하는 결과를 깔끔하게 구현할 수 있는데요. 오늘은 검색과 더불어 특정 데이터를 선택하는 작업인 매핑에 대해 알아보려 합니다.


계속해서 알기 쉬운 SQL에 비교하여 알아보겠습니다.


우리는 DBMS에 질의를 할 때, 언제나 테이블의 ROW 데이터 모두를 원하지 않습니다. 질의어 자체에서 출력 결과를 조정할 수 있으며, 선택을 할 수 있습니다. 예를들어 "구성원이라는 테이블에, 이름만 출력" 하고자 한다면 이렇게 사용을 하죠.


1
2
3
4
5
6
SELECT
    member.name
FROM
    member as member
WHERE
    member.age = 40
cs


JAVA8에서는 map 메소드를 사용하여 특정 필드의 결과만을 가지는 Collection을 생성할 수 있습니다. 함수형 인터페이스로 친다면 Function 의 성격을 가지고 있습니다. (T를 받아 R을 출력하고 있으니 말이죠 ㅡㅡ^) 


함수형 인터페이스의 성격이 무슨 말인지 모르신다면 해당 포스트를 참고하세요.


2016/07/28 - [개발이야기/함수형 프로그래밍] - JAVA8 에 정의된 함수형 인터페이스


다시 돌아와서, map의 활용을 보도록하겠습니다.


일단 테스트VO 클래스에 대한 명시입니다.


1
2
3
4
5
6
public class MemberVo {
    private Integer sn;
    private Integer age;
    private String name;
}
 
cs


위 VO는 구성원을 가르키며, 고유넘버, 나이, 이름 정도의 멤버 변수를 가지고 있습니다. 

상단의 언급한 SQL 쿼리의 로직을 수행해보도록 하죠!


Map의 활용


1
2
3
4
5
6
7
8
9
10
List<MemberVo> memberList = Arrays.asList(
                new MemberVo(1, 27, "남두현"), new MemberVo(2, 20, "유형주"),
                new MemberVo(3, 20, "태재영"), new MemberVo(4, 40, "남궁계홍"));
        
memberList.stream()
    .filter(a -> a.getAge().intValue() == 40)
    .map(MemberVo::getName)
    .forEach(System.out::println);
 
console value : 남궁계홍
cs


지난번에 배웠던 검색 메소드인 filter를 이용하여 나이에 대한 조건을 언급하였고, map 메소드를 이용하여 이름이라는 데이터를 출력하였습니다.


보다 다양한 결과를 출력하고 싶다면, map 메소드의 파라미터안에 적절한 람다 혹은 메소드 레퍼런스를 언급해주면 됩니다.


JAVA 8 IN ACTION 에서는 이러한 map 과 더불어, flatMap을 같이 소개했습니다. flatMap의 기능은 스트림의 평면화로, 두 개의 컨테이너 객체의 스트림을 하나로 묶는 것을 말합니다. (쉽게 말해서 SQL의 JOIN과 같다고 볼 수 있습니다. ㅡㅡ^)


flatMap을 이용하여 두 테이블을 합친 로직을 구현해볼까요?


FlatMap의 활용


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
List<MemberVo> memberList = Arrays.asList(new MemberVo(1, 27, "남두현"), new MemberVo(2, 20, "유형주"),
                new MemberVo(3, 20, "태재영"), new MemberVo(4, 40, "남궁계홍"));
List<BoardDetailVo> boardList = Arrays.asList(new BoardDetailVo(1, "람다게시판입니다.", "람다에 관련된 클만 올려주세요."),
                new BoardDetailVo(1, "람다란 무엇이니가?", "함수형 프로그래밍의 꽃?"),
                new BoardDetailVo(2, "물어볼 게 있습니다.", "람다공부는 어떻게 하죠?"));
 
memberList.stream().flatMap(i ->
        boardList.stream()
        .filter(j -> j.getSn() == i.getSn().intValue())
        .map(j -> {
                MemberBoardResultVo result = new MemberBoardResultVo();
                result.setSn(i.getSn());
                result.setName(i.getName());
                result.setContents(j.getContens());
                result.setTitle(j.getTitle());
                return result;
        })).forEach(ret -> {
                System.out.println(String.format("[%s]%s:%s", 
                    ret.getName(), 
                    ret.getTitle(), 
                    ret.getContents()));
            }
        );
 
- console result -
 
[남두현]람다게시판입니다.:람다에 관련된 클만 올려주세요.
[남두현]람다란 무엇이니가?:함수형 프로그래밍의 꽃?
[유형주]물어볼 게 있습니다.:람다공부는 어떻게 하죠?
 
cs


일단 chain된 Stream 이 살짝 복잡해 보이네요. 파이프 하나씩 한번 살펴보죠!


flatMap 내부부터 한번 살펴보면,


1. memberList의stream이 주가 되어, flatMap 내부에서 boardList의 Stream을 사용하고 있습니다.


1
memberList.stream().flatMap(i -> boardList.stream()....)
cs



2. boardList의 stream 내부 파이프라인 중 filter는 memberList 의 각 객체 중, 본인 객체의 sn이 서로 같은 것만 찾으라는 조건을 명시하고 있습니다.


1
filter(j -> j.getSn() == i.getSn().intValue())
cs


3. boardList stream의 내부 map에서는 Function 의 역할로 MemberBoardResultVo 를 출력하도록 되어 있습니다. 람다표현식을 사용하여, MemberVo와 BoardDetailVo 에서 각각 필요한 정보를 주입합니다.


1
2
3
4
5
6
7
8
map(j -> {
                MemberBoardResultVo result = new MemberBoardResultVo();
                result.setSn(i.getSn());
                result.setName(i.getName());
                result.setContents(j.getContens());
                result.setTitle(j.getTitle());
                return result;
        })
cs


4. foreach에서는 위의 flatMap으로부터 출력된 컨테이너를 순회하며, 필요한 정보를 출력하고 있습니다.


1
2
3
4
5
6
7
forEach(ret -> {
                System.out.println(String.format("[%s]%s:%s", 
                    ret.getName(), 
                    ret.getTitle(), 
                    ret.getContents()));
            }
        );
cs


람다식이 조금 복잡해보이지만, 사실 기존 java8 이전의 구현 방식대로 진행한다고 하면, 2중 for-loop을 통해 보다 복잡한 로직이 될 수 있습니다. 위의 예제는 비교적 간단해보이지만, 컬렉션 3~4개를 합친다거나, 합쳐진 컬렉션에서 limit, skip, order by 등의 추가사항이 붙는다면 기존 구현된 소스를 보고 고민에 빠지는 시간이 조금 길어질것입니다.


하지만 람다식을 통해 다음과 같이 chain 메소드 한개만 출력해주면 간단히 해결이 됩니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
memberList.stream().flatMap(i ->
            boardList.stream()
            .filter(j -> j.getSn() == i.getSn().intValue())
            .map(j -> {
                    MemberBoardResultVo result = new MemberBoardResultVo();
                    result.setSn(i.getSn());
                    result.setName(i.getName());
                    result.setContents(j.getContens());
                    result.setTitle(j.getTitle());
                    result.setAge(i.getAge());
                    return result;
        }))
        .sorted((a, b)-> a.getAge().compareTo(b.getAge()))
        .limit(1)
        .forEach(ret -> {
                System.out.println(String.format("[%s]%s:%s", 
                        ret.getName(), 
                        ret.getTitle(), 
                        ret.getContents()));
            }
        );
 
- console result -
[유형주]물어볼 게 있습니다.:람다공부는 어떻게 하죠?
cs


단순히, 두 객체를 머징하는 내부 람다에 age를 추가 하였고, sorted와 limit를 사용하였습니다.


즉 우리는 이번 포스팅을 통해 알 수 있었던 것은 컨테이너를 사용하는 로직에서 


단순히 체인형 stream을 추가하는 방법만으로 변화에 보다 쉽고 유연하게 대처


할 수 있음을 알게 되었습니다.



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기



반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API 활용편4 (리듀싱)  (0) 2017.01.23
Stream API 활용편3 (검색과 매칭)  (0) 2017.01.18
Stream API 활용편1 (필터와 슬라이싱)  (0) 2016.08.26
Stream과 Collection 차이  (0) 2016.08.04
Stream API  (0) 2016.08.03
Posted by N'
,

Stream API 활용편1 (필터와 슬라이싱)

개발이야기/함수형 프로그래밍2016. 8. 26. 22:56

안녕하세요. 블로그 주인인 초보프로그래머입니당.


오랜만의 블로그 포스팅입니다.  개인적으로 바쁜 일이 있어서(곧 회사내에서 출시를 하기 때문에 버그를 열심히 잡았죠... ㅡㅡ^), 오랜만에 공부를 해보고 내용을 정리하게 되었습니다.


솔직히 블로그할 시간은 있긴 했지만, 게을러지다보니 공부하게 되는 것이 쉽지가 않네요.


하지만 책을 산 것이 아깝고, 곧 진행했던 안드로이드 프로젝트에도 함수형 프로그래밍의 결실을 시도해봐야하니(RxJava or Android N) 다시 한번 붙잡게 되었습니다.


그런 의미에서 오늘은 계속 진행하던 Stream API 의 활용에 대해 보고자 합니다. 

Stream API에 대해 처음보게 된다면 이 곳을 먼저 확인해주세요.


2016/08/03 - [개발이야기/함수형 프로그래밍] - Stream API


이전에 Stream API를 소개할 때, 컨테이너(Collection)의 활용을 질의 형태로 작성할 수 있다고 언급했었는데요. 마치 고수준 언어인 SQL을 사용하듯 말이죠. (Collection 객체를 테이블이라고 본다면, 질의를 통해 어떤 결과를 얻는다 생각하면 좋겠네요? ㅡㅡ^)


오늘은 그 중 필터링과 슬라이싱(즉 검색.. ㅡㅡ^)을 해보려 합니다.


1. 필터링

SQL의 where 절과 같은 역할입니다. Collection 객체 중 프리디케이트(Predicate)에 부합하는 객체들을 따로 추출하는 역할을 합니다. 그 메소드는 이전부터 많은 예제로 사용되었던 filter 입니다. 


몸풀기로 시작해보겠습니다.


1
2
3
4
5
6
7
8
9
List<Integer> numberList = Arrays.asList(2, 2, 3, 4, 5, 6, 8, 8, 9, 10);
 
for (Integer a : numberList.stream().filter(a -> a % 2 == 0).
                collect(Collectors.toList())) {
    System.out.println(a);
}
 
console result : [2,2,4,6,8,8,10]
 
cs


filter 메소드를 이용하여, 짝수만을 조회하였습니다. SQL로 치자면, 이정도??


1
SELECT number FROM NUMBERLIST WHERE number % 2 = 0;

cs


2. 고유 요소 필터링

위의 결과 중, 중복된 결과가 있습니다. 원하는 결과가 중복된 값이 없기를 바란다면 distinct 메소드를 사용해주면 됩니다.


1
2
3
4
5
for (Integer a : numberList.stream().filter(a -> a % 2 == 0).
                distinct().collect(Collectors.toList())) {
    System.out.println(a);
}
 
cs


생각해보면 SQL에서 DISTINCT 를 사용하여, 고유 결과를 출력할 수 있다는 것을 알고 있습니다.


1
SELECT DISTINCT number FROM NUMBERLIST WHERE number % 2 = 0;
cs


3. 결과값 제한과 스킵

보통 게시판을 만들 때, limit offset 등을 사용하여 페이징 처리를 하곤 합니다. 왜냐하면 많은 데이터를 한번에 다 보여줄 수도 없거니와, 사용도 불편하기 때문이죠.


Stream API에서는 limit offset 과 같은 역할을 해줄 수 있는 메소드 역시 가지고 있습니다.


일단 Stream을 잘 살펴보면, limit 라는 메소드를 가지고 있습니다. 아래 코드는 Stream의 결과 중, 3개를 반환하는 메소드입니다.


1
2
3
numberList.stream().filter(a -> a % 2 == 0).distinct().limit(3).forEach(System.out::println);
 
console result : [2,4,6]
cs


재미있는 점은 limit를 사용하지 않은 결과보다, limit의 파라미터 값이 크더라도 에러를 출력하지 않습니다. 이 점은 우리가 최대 몇개를 가져온다라는 비지니스 로직을 구현할 때, 방어코드를 할 필요가 없어졌음을 말합니다.


마지막으로 skip을 이용하여, 요소를 건너뛸 수 있습니다. 예를들어 3번째 결과부터 2개 출력이라 하면 이렇게 응용을 할 수 있습니다.


1
2
3
numberList.stream().filter(a -> a % 2 == 0).distinct().skip(3).limit(2).forEach(System.out::println);
 
console result : [8,10]
cs


skip역시 입력받는 파라미터에 대해 방어코드를 할 필요가 없습니다. 조건에 만족하지 못한다면 빈 배열을 출력합니다.



오늘 포스팅에서는 Stream API를 이용한 필터 및 슬라이싱하는 방법을 알아봤습니다. 


어느정도 함수형 프로그래밍의 감이 오시나요? 


오늘 포스팅으로 부터 알 수 있는 점은 함수형 프로그래밍으로 비지니스 로직을 구현 시,


1. 간편하고, 직관적인 선언형 위주의 구현


2. 방어코드 없이, 오류가 적은 코드의 구현


이라는 장점을 볼 수 있었음을 알 수 있었습니다.




자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기


반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API 활용편3 (검색과 매칭)  (0) 2017.01.18
Stream API 활용편2 (매핑)  (0) 2016.08.27
Stream과 Collection 차이  (0) 2016.08.04
Stream API  (0) 2016.08.03
람다 조합  (0) 2016.08.02
Posted by N'
,

Stream과 Collection 차이

개발이야기/함수형 프로그래밍2016. 8. 4. 01:21

지난 포스팅부터 "본격 선언형 프로그래밍을 할 수 있게 해준 Stream API" 에 대해 포스팅하고 있습니다. 

(모던해지는 자바에서 lambda와 더불어 선언형 프로그래밍이 어느정도 대세가 되지 않을까요? ㅡㅡ^)


2016/08/03 - [개발이야기/함수형 프로그래밍] - Stream API


오늘 포스팅에서는 "데이터 처리 연산을 지원하도록 추출된 연속된 요소 (JAVA8 IN ACTION 에서 인용)" 인 Stream 과 기존 Collection 의 차이에 대해 포스팅해보려 합니다. 


여기에서 연속된 요소라는 정의는 순차적으로 접근가능한 요소라는 점에서, Collection 과 Stream의 큰 차이는 데이터 저장 우선 vs 연산 우선 이라 볼 수 있을 것 같네요.


기존 Collection 은 데이터를 어떻게 잘 저장하고 접근할 것이냐에 초점을 맞췄습니다. 내부 요소에 대한 처리를 하기 위해서는 외부적으로  for-loop 를 통해 각각의 데이터에 접근하며, 비지니스 로직을 처리해야 합니다(외부 반복). 즉 어떤 처리를 위해서 Collection 내부에 모든 값을 가지고 있어야 합니다.


반면 Stream 의 경우 어떻게 처리를 할 것인가에 초점을 맞췄는데요. Stream 은 내부적으로 반복 과정을 숨겨 알아서 처리하고 결과를 어딘가에 출력하는 과정을 수행합니다. (내부 반복)  내부 반복을 사용하는 덕분에 우리는 컨테이너 처리에 대하여 순차적으로나 병렬적으로 처리를 간단하게 설정할 수 있게 되었어요. 아래 코드는 순차처리와 병렬 처리에 대한 간단한 코드입니다.


1
2
3
4
5
6
7
8
9
10
dataList.stream().filter((a) -> a % 7 == 0).sorted((a, b) -> b.compareTo(a)).limit(4)
        .forEach(System.out::println);        // 순차 처리
 
dataList.parallelStream().filter((a) -> a % 7 == 0).sorted((a, b) -> a.compareTo(b)).limit(4)
        .forEach(System.out::println);        // 병렬 처리
 
/*
* 위의 코드 중 병렬 처리는 의도된 결과가 나오지 않습니다. 병렬로 처리를 하기 때문에 
* parallelStream 의 사용은 "이 일이 병렬로 처리가능한가?" 를 생각해보고 사용해야합니다.
*/
cs


또한 Stream 의 처리 과정은 이론적으로 요청하는 값에 대해서만 처리를 하겠다는 핵심적인 내용이 있습니다. 이 것은 요청할 때만 처리하여, collection은 게으르게 만들겠다는 소리인데... 이 것 역시 예제로 보면 좋을 것 같아요. 


무한한 짝수를 표현해야하는 컨테이너의 문제에 대하여,


Collection은 아래과 같이 데이터를 우선적으로 만들고 있어, 소비는 할 수 없네요.


1
2
3
4
5
6
7
8
ArrayList<Integer> intList = new ArrayList<>();
for (int i = 0;; i+=2) {
    intList.add(i);
}

// 영원히 소비가 불가능합니다.
for (int i = 0, size = intList.size(); i < size; ++i){
    System.out.println(intList.get(i));
}
cs


반면 Stream 의 경우 무한한 짝수를 모두 만들기보다는 들어오는 요청에 대해서 즉시 만들어 소비하죠. (연속적인 요소가 어떻게 처리가 되는지에 대한 과정을 보기 위한 것이므로, for-loop 내부에 log 를 찍는 경우는 생각안하겠습니다.)


1
2
3
4
IntStream intList = IntStream.iterate(0, (i) -> i+2);;
intList.forEach(System.out::println);
 
// result : 0,2,4,6 ......
cs


사실 이러한 특성들은 사실 모두 비지니스 로직으로 풀어갈 수 있는 문제로 보이네요. 

하지만 이러한 것들을 미리 알아두는 게, 보다 더 편리하고 뻐그없겠금 사용할 수 있게 도와주지 않을까요?  




자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기

반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API 활용편2 (매핑)  (0) 2016.08.27
Stream API 활용편1 (필터와 슬라이싱)  (0) 2016.08.26
Stream API  (0) 2016.08.03
람다 조합  (0) 2016.08.02
메서드 레퍼런스  (0) 2016.08.01
Posted by N'
,

Stream API

개발이야기/함수형 프로그래밍2016. 8. 3. 23:14

JAVA8 이 기존 JAVA와 달라진 부분은 단지 람다표현식이 추가된 것만 있는 것은 아닌 것 같아요. 


람다 표현식과 더불어 같이 추가된 것은 컨테이너(Collection)를 사용하는 비지니스 로직을 보다 간결하고(쉽지는 않을듯? 배워야하기 때문이죠.. ㅡㅡ^ ) 성능 좋게 만들 수 있는 Stream API의 등장은 clean code 제작에 많은 도움이 될 것같습니다.


요즘 개발하고 있는 Spring 기반의 back단 작업이나 안드로이드위에서 작성하는 비지니스 로직은 DB를 껴안고 있기 때문에 컨테이너를 자주 사용하게 되고, 당연히 루프를 돌면서 이 작업, 저 작업을 하게 됩니다.


비지니스 로직에 따라 if, break, continue 등 여러 문법 등을 사용하게 되고, 때에 따라 복잡해지는 것을 작성해줘야하지만 Stream API를 사용하면 내가 무슨일을 해야한다는 것을 어떤 규칙에 따라 선언만 해주면 되는 선언형 프로그래밍을 할 수 있습니다. (SQL 질의 처럼 말이죠. SQL 질의어를 사용하면 복잡한 key-value 기반의 테이블에서 효과적으로 데이터를 찾을 수 있죠. 찾는 로직은 몰라도 되고요.)


예를 들면 다음과 같은 코드를 볼 수 있습니다. dataList 라는 컨테이너를 이용해서 같은 로직을 작성해보겠습니다.


1
2
3
4
5
6
7
8
LinkedList<Integer> dataList = new LinkedList<Integer>() {
    {
        Random random = new Random();
        for (int i = 0; i < 100; ++i) {
            add(random.nextInt(100));
        }
    }
};
cs


아래는 기존 JAVA8 이전 Collection을 loop돌면서 컨테이너 내부의 가장 큰 7의 배수 4개를 찾는 것입니다. (아무리 라인수를 줄일려고 해도 저는 이정도가 한계인가 봅니다. ㅜㅡㅜ)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Collections.sort(dataList, new Comparator<Integer>() {
    @Override
    public int compare(Integer arg0, Integer arg1) {
        // TODO Auto-generated method stub
        return arg1.compareTo(arg0);
    }
});
 
for (int i = 0, count = 0, size = dataList.size(); i < size && count < 4; ++i) {
    if (dataList.get(i) % 7 == 0) {
        System.out.println(dataList.get(i));
        ++count;
    }
}
 
cs


다음은 Stream API를 사용한 로직입니다.


1
2
dataList.stream().filter((a) -> a % 7 == 0).sorted((a, b) -> b.compareTo(a)).limit(4)
                .forEach(System.out::println);
cs


stream 내부 메소드를 이용해 질의를 하듯이 코드를 작성하였습니다. 정말 간단해졌죠?


이와같이 Stream API를 이용하면 단순히 비지니스 처리를 선언으로 하기 때문에 쉽게 구현할 수 있으며, 각각의 블럭 (sorted나 filter) 등이 chain 형식을 지원하기 때문에 복잡한 로직에 대해 가독성과 명확성을 확실시 해줄 수 있을 것같습니다. (즉 파이프라인 구조입니다.)


또한 내부적으로는 데이터 처리과정을 병렬화할 수 있기 때문에 성능을 더 좋게 만들 수 있습니다. 

(물론 병렬을 위한 thread 처리에 대해서는 신경쓰지 않아도 됩니다.)


이와같은 Stream API의 특징을 JAVA8 IN ACTION에서는 다음과 같이 요약하고 있습니다.


1. 선언형

더 간결하고 가독성이 좋아집니다.


2. 조립할 수 있음

유연성이 좋아집니다.


3. 병렬화

성능이 좋아집니다.


그럼 여기에서, Stream의 구조에 대해서 조금 더 살펴보죠.

Stream 을 사용하는 구조는 크게 데이터 소스를 받는 것과 비지니스 로직에 대한 각종 컨디션을 파이프라인으로 구성하기 위한 중간 연산, 구성할 파이프라인을 실행할 최종 연산정도 있습니다.


위의 작성한 코드를 살펴보면 다음과 같이 나타낼 수 있네요.


1
2
3
4
dataList.stream()        // 데이터 소스 
.filter((a) -> a % 7 == 0).sorted((a, b) -> b.compareTo(a)).limit(4)  // 중간 연산
.forEach(System.out::println);    // 최종 연산
 
cs


위의 역할을 살펴보면, dataList 로 부터 데이터 소스를 받아오고 있으며, 7의 배수, 내림차순, 선착순 4개 등 chain 형식으로 각종 컨디션을 연결한 중간 연산과정이 있으며, 이러한 조건의 값들을 console에 표시하겠다는 최종 연산으로 나누어짐을 알 수 있습니다. 

(Stream API에서 제공하는 보다 더 다양한 연산은 다음에 정리하여, 포스팅하도록 하겠습니다. )


이러한 Stream API를 이용한 스트림 요소의 연산은 오직 딱 한번만 사용(소비)할 수 있습니다. 예를들어 이 것은 예외를 일으킵니다.


1
2
3
4
5
6
7
Stream<Integer> stream = dataList.stream();
 
stream.filter((a) -> a % 7 == 0).sorted((a, b) -> b.compareTo(a)).limit(4)
        .forEach(System.out::println);    
stream.filter((a) -> a % 7 == 0).sorted((a, b) -> a.compareTo(b)).limit(10)
        .forEach(System.out::println);        // IllegalStateException 예외 발생
 
cs


아래는 예외 메시지입니다.


1
2
3
4
5
6
7
8
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    at java.util.stream.AbstractPipeline.<init>(Unknown Source)
    at java.util.stream.ReferencePipeline.<init>(Unknown Source)
    at java.util.stream.ReferencePipeline$StatelessOp.<init>(Unknown Source)
    at java.util.stream.ReferencePipeline$2.<init>(Unknown Source)
    at java.util.stream.ReferencePipeline.filter(Unknown Source)
    at testClass.main(testClass.java:40)
 
cs


이것으로 Stream API 에 대한 Summary 정도는 여기까지 포스팅하겠습니당. 

(나머진 필요한 것 따라 메소드를 사용해주면 되지 않을까요? 그래서 Summary 입니다. ㅡㅡ^)



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기




반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API 활용편1 (필터와 슬라이싱)  (0) 2016.08.26
Stream과 Collection 차이  (0) 2016.08.04
람다 조합  (0) 2016.08.02
메서드 레퍼런스  (0) 2016.08.01
람다의 실제 형식  (0) 2016.07.28
Posted by N'
,

람다 조합

개발이야기/함수형 프로그래밍2016. 8. 2. 00:03

현재 보고 있는 책인 JAVA8 IN ACTION 에서는 람다에 대해서 너무 자세히 다루고 있습니다. 

덕분에 많은 공부가 되었고, 포스팅 개수도 많이 늘어나고 있는 것 같습니다. ㅡㅡ^


오늘은 람다에 대한 마지막 포스팅은 람다를 연결해서 사용하는 방법에 대해 알아보려고 합니다. 


람다가 수학식에 대하여 추상화를 한 것이라 했을 때, 우리는 각 식을 조합하여 복잡한 식을 만들 수 있다는 것을 생각해 볼 수 있습니다. 

(잘 생각해보면, 굳이 람다가 아니더라도 if 절을 사용할 때 and 나 or 등을 사용하여 복잡한 컨디션을 만들고 있지 않나요?)


JAVA8은 람다 표현식을 더욱 적극적으로 사용할 수 있도록, 람다를 조합을 하거나 혹은 편리하게 사용하게 해줄 수 있는 메소드를 제공해줍니다.


1. Comparator 


- reverse 메소드를 이용하여 역정렬을 사용할 수 있습니다.


1
2
3
4
5
List<Apple> dataList = new ArrayList<>();
Comparator<Apple> compare = Comparator.comparing(Apple::getWeight);
dataList.sort(compare);
dataList.sort(compare.reversed());
 
cs


- thenComparing 메소드를 조건을 더 연결할 수 있습니다.


1
2
// 무게가 같다면, 컬러로 
dataList.sort(Comparator.comparing(Apple::getWeight).reversed().thenComparing(Apple::getColor));
cs



2. Predicate


- negate 메소드를 사용하여 반대 (!) 를 사용할 수 있습니다.


1
2
3
4
5
6
BiFunction<String, Integer, Apple> creator2 = Apple::new;
Apple apple2 = creator2.apply("green", 100);
 
Predicate<Apple> isNotHeavy = (v) -> v.getWeight() > 150;
System.out.println(isNotHeavy.negate().test(apple2)); // true 
 
cs


- and나 or를 사용할 수 있습니다.


1
2
3
4
5
Predicate<Apple> isNotHeavy = (v) -> v.getWeight() > 150;
 
// 사과의 무게는 150 이상 200 이하 이거나, 색이 green 인 경우
isNotHeavy.and((v) -> v.getWeight() < 200).or((v) -> v.getColor().equals("green")).test(apple2);
 
cs



3. Function


우리가 보통 함수를 처음 배울 때, 이러한 표현을 배운적이 있습니다.


f(x) = x + 1

g(x) = x * 2


g(f(x)) = (x + 1) * 2


위와 같은 역할을 해줄 수 있는 메소드가 존재합니다. (andThen, compose)


1
2
3
4
5
6
Function<Integer, Integer> f = (x) -> x + 1;        // f(x)
Function<Integer, Integer> g = (x) -> x * 2;        // g(x)
        
Function<Integer, Integer> fg = f.andThen(g);     // g(f(x))
Function<Integer, Integer> gf = f.compose(g);    // f(g(x))
 
cs



람다를 이어줌으로써, 복잡한 식을 보다 쉽게 작성할 수 있지만 아무래도 복잡한 식에 대해서는 메서드 레퍼런스를 사용하는 것이 좋아보입니다.


만드는 것은 간단해보일 수 있으나, 유지보수적인 면도 봐야겠죠. ㅎㅎ


2016/08/01 - [개발이야기/함수형 프로그래밍] - 메서드 레퍼런스


이 것으로 람다에 대한 포스팅은 끝!!!!  :-)


다음 포스팅부터는 자바8의 꽃인 Stream API에 대해 다루어 보려 합니다.



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기


반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream과 Collection 차이  (0) 2016.08.04
Stream API  (0) 2016.08.03
메서드 레퍼런스  (0) 2016.08.01
람다의 실제 형식  (0) 2016.07.28
클로저와 람다  (2) 2016.07.28
Posted by N'
,

메서드 레퍼런스

개발이야기/함수형 프로그래밍2016. 8. 1. 23:17

계속해서 람다와 관련된 포스팅을 하고 있습니다. 


람다는 익명 클래스를 어느정도 대체를 해줄 수 있는 것처럼 보이며, 간단한 처리는 대부분 람다를 이용하게 되지 않을까요? 

(예를들어 안드로이드에서 이벤트 처리 시, 익명클래스의 대체가.. ㅡㅡ^ ) 


람다와 람다를 왜 써야하는지 보려면 이 곳으로...


2016/07/25 - [개발이야기/함수형 프로그래밍] - 동작 파라미터화와 함수형 프로그래밍 (1)


2016/07/27 - [개발이야기/함수형 프로그래밍] - 람다 표현식


오늘은 람다표현식과 더불어, 간결성과 더불어, 가독성까지 챙길 수 있는 메서드 레퍼런스에 대하여 포스팅하려 합니다.


JAVA 8 IN ACTION 에 따르면, 메서드 레퍼런스는 특정 메서드만을 호출하는 람다의 축양형 이라고 볼 수 있다고 합니다. 

즉 람다를 통해 어떻게 어떤식의 메서드를 사용하라가 아닌, 메서드의 이름만을 참조하여 처리한다고 볼 수 있습니다. (그래서 레퍼런스라고 하나 봅니다... ㅎㅎ)


예를 들어, 이런 것을 볼 수 있을 것 같습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
class Apple {
    private int weight;
 
    public int compareTo(Apple apple){
        if (weight >= apple.getWeight()) return 0;
        else if (weight <= apple.getWeight()) return 1;
        else return -1;
    }
}
 
inventory.sort((Apple a, Apple b) -> a.compareTo(b));
inventory.sort(Apple::compareTo); // -> 메서드 레퍼런스
 
cs


저는 이 것을 보면서 처음에 이해가 안됐던 부분이 파라미터는 어떻게 넣을 것이냐라는 것이었습니다. 

람다의 경우 파라미터 영역이 따로 명시되어 있지만 메서드 레퍼런스는 (Apple::compareTo) 다음과 같이 명시가 되어있지 않습니다. 

그러나 이 것은 sort 매개변수 넣을 당시, 람다표현식에 대한 형식검사를 함을 알 수 있습니다. sort의 파라미터로 람다 표현식을 사용 시, 람다 디스크립터를 맞춰야 한다는 것은 지난 포스팅 때 언급을 했었습니다.


2016/07/28 - [개발이야기/함수형 프로그래밍] - 람다의 실제 형식



즉 이런한 점을 이용해, 람다 디스크립터에 맞춰 메서드 레퍼런스를 사용해주면 됨을 알게 되었습니다.


JAVA8 IN ACTION 에서는 메서드 레퍼런스를 만드는 법은 크게 세가지로 보고 있습니다.


1. 정적 메서드 레퍼런스 (정적 메서드 - static 메서드라 생각합시다.)


예를들어 Integer 클래스의 parseInt 메서드는 정적 메서드로, String 객체를 Integer 형태로 변경해줍니다. 해당 메서드는 다음과 같이 인수로써 가질 수 있습니다.


1
2
3
Function<String, Integer> parse = Integer::parseInt;
int a = parse.apply("5");
 
cs



2. 다양한 형식의 인스턴스 메서드 레퍼런스 (일반 메서드라 생각합시다.)


클래스에 정의 된 일반 메서드를 인수로 가질 수 있음을 말합니다. 아래는 List의 메소드인 size() 를 인수로 가지는 예제입니다.


1
2
3
4
5
6
7
8
9
10
List<String> strList = new ArrayList<String>() {
    {
        add("A");
        add("B");
        add("C");
    }
};
 
Function<List, Integer> size = List::size;    // 일반 메서드의 메서드 레퍼런스
System.out.println(size.apply(strList));     // 3 
cs




3. 기존 객체의 인스턴스 메서드 레퍼런스 


인스턴스 객체를 이용하여, 메서드 레퍼런스를 사용할 수 있습니다. 

예를들면 이런식으로 사용이 가능해보입니다. 


1
2
3
4
5
6
7
8
9
10
List<String> strList = new ArrayList<String>() {
    {
        add("A");
        add("B");
        add("C");
    }
};
        
Consumer<String> consume = strList::add; 
consume.accept("E");
cs


메소드레퍼런스를 사용하려는 대상 메소드가 다형성에 의해 가려질 때 사용할 듯 합니다.



4. 생성자 레퍼런스


new 키워드를 사용하여, 생성자의 레퍼런스를 만들 수 있습니다. 아래와 같이 작성이 가능합니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Apple {
    private String color;
    private int weight;
    
    public Apple(){}
    
    public Apple(String color, Integer weight){
        this.color = color;
        this.weight = weight;
    }
}
 
Supplier<Apple> creator = Apple::new;    // 기본 생성자에 대한 메서드 레퍼런스
Apple apple = creator.get(); 
 
// color 와 weight 를 받아 Apple을 만드는 생성자의 메서드 레퍼런스
BiFunction<String, Integer, Apple> creator2 = Apple::new; 
Apple apple2 = creator2.apply("green", 100);
 
cs


위와 같이 다양한 시그니처 생성자에 대하여 메서드 레퍼런스를 사용할 수 있습니다.



이러한 메서드 레퍼런스를 람다표현식을 직접 사용하지 않고 사용하는 이유는 복잡한 람다식을 일일이 명시하는 것보다 가독성이 좋기 때문입니다. 


즉 람다식이 복잡하다면, 차라리 메소드로 정의하여 처리하는 것이 좋아보입니다.



자바 8 인 액션
국내도서
저자 : 라울-게이브리얼 우르마(RAOUL-GABRIEL URMA),마리오 푸스코(MARIO FUSCO),앨런 마이크로프트(ALAN MYCROFT) / 우정은역
출판 : 한빛미디어 2015.04.01
상세보기




반응형

'개발이야기 > 함수형 프로그래밍' 카테고리의 다른 글

Stream API  (0) 2016.08.03
람다 조합  (0) 2016.08.02
람다의 실제 형식  (0) 2016.07.28
클로저와 람다  (2) 2016.07.28
원시타입을 위한 함수형 인터페이스  (0) 2016.07.28
Posted by N'
,
Daum / Designed by i2i Labs

티스토리툴바