ABOUT ME

-

Today
-
Yesterday
-
Total
-
  • [Java 8] 람다식을 사용해보자 How to use lamda
    백엔드/부족한 기본 정리 2020. 11. 3. 21:43

          로재의 개발 일기      

    자바의 비기 람다

    람다식을 제대로 공부해본 적이 없어서

    이전에 공부한 자료를  개인 학습으로 남기는 부분입니다.


    잊고 포스팅을 하지 않으면, 계속 안 할것 같아서...



     Stream을 사용해보자

    List의 경우

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    List<String> list = Arrays.asList("rojae""yeong""suji""sujeong");
     
    // 기존의 방법 
    for(String i : list) {
        if(i.contains("s"))
            System.out.println(i);
    }
     
    /* 람다 스트림 사용 
     * .steam() : 스트림
     * .filter : 중간연산 필터링 작업 
     * forEach : 최종연산 
     */
    list.stream().filter(x -> x.contains("s")).forEach(x -> System.out.println(x));
    //list.stream().filter(x -> x.contains("s")).limit(1).forEach(x -> System.out.println(x));
    cs


    결과 
    1
    2
    3
    4
    5
    suji
    sujeong
    suji
    sujeong
     
    cs



    ArrayList의 경우

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    ArrayList<String> list = new ArrayList<>(Arrays.asList("rojae""yeong""suji""sujeong"));
     
    // 기존의 방법 
    for(String i : list) {
        if(i.contains("s"))
            System.out.println(i);
    }
     
    /* 람다 스트림 사용 
     * .steam() : 스트림
     * .filter : 중간연산 필터링 작업 
     * forEach : 최종연산 
     */
    list.stream().filter(x -> x.contains("s")).forEach(x -> System.out.println(x));
    //list.stream().filter(x -> x.contains("s")).limit(1).forEach(x -> System.out.println(x));
    cs



    결과 

    1
    2
    3
    4
    5
    suji
    sujeong
    suji
    sujeong
     
    cs



     Collection도 사용해보자

    소스코드

    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
    ArrayList<String> list = new ArrayList<>(Arrays.asList("alpha""beta""delta""theta"));
    ArrayList<String> list2 = new ArrayList<>(Arrays.asList("alpha""beta""delta""theta"));
     
    // 기존의 방법
    for (String i : list) {
        if (i.contains("l"))
            System.out.println(i);
    }
     
    /*
     * 람다 스트림 사용 .steam() : 스트림 .filter : 중간연산 필터링 작업 forEach : 최종연산
     */
    list.stream().filter(x -> x.contains("l")).forEach(x -> System.out.println(x));
     
    Stream<String> s = list.stream().map(x -> x.substring(0,1)).sorted(Comparator.naturalOrder());
    s.forEach(System.out::println);
    s.close();
     
    // 기존의 방법
    // 1. ArrayList 전체 순환
    // 2. 'l' 존재시 '++'을 붙인다.
    // 3. 없으면 제거 
    // 4. 기존 객체는 그대로 사용 
    for(int i = 0; i < list.size(); i++) {
        if(list.get(i).contains("l")) {
            String tmp = list.get(i);
            list.remove(i);
            list.add(i, tmp+"++");
        }
        else {
            list.remove(i);
            i--;
        }
    }
    System.out.println(list);
     
    // lamda 
    list2 = list2.stream().filter(x -> x.contains("l")).map((x) -> {return x.concat("++");} ).collect(Collectors.toCollection(ArrayList::new));
    System.out.println(list2);
    cs


    결과

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    alpha
    delta
    alpha
    delta
    a
    b
    d
    t
    [alpha++, delta++]
    [alpha++, delta++]
     
    cs




     Predicate도 넣어보자

    소스코드

    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
    ArrayList<String> list = new ArrayList<>(Arrays.asList("alpha""beta""delta""theta"));
    ArrayList<String> list2 = new ArrayList<>(Arrays.asList("alpha""beta""theta""omega"));
     
    /*
     *  stream : 스트림 생성
     *  filter : 연산 수행
     *      list : x
     *      list2.stream : 스트림 생성
     *      allMatch : list2의 스트림과 x의 비교
     *                  모든 값이 맞는 경우 true : false
     *  collect     
     *         ArrayList로 변환 
     */
    ArrayList<String> res = list.stream().filter(x -> list2.stream()
            .anyMatch(Predicate.isEqual(x)))
            .collect(Collectors.toCollection(ArrayList::new));
     
    res.stream().forEach(x -> System.out.println(x));
     
    //기존의 방법
    ArrayList<String> res2 = new ArrayList<>();
     
    for(String s : list) {
        if(list2.contains(s))
            res2.add(s);
    }
     
    System.out.println(res2);
    cs


    결과

    1
    2
    3
    4
    alpha
    beta
    theta
    [alpha, beta, theta]
    cs



    마무리

    주요용어 Stream, Lamda, Predicate, filter, concat...



    ※ 본 글은 개인 포트폴리오 혹은 공부용으로 사용하기 때문에, 무단 복사 유포는 금지하지만, 개인 공부 용도로는 얼마든지 사용하셔도 좋습니다




    반응형
Designed by Tistory.