컴퓨터 공부하는 블로그

람다와 스트림 - collect() part 2

ksge7 — Wed, 19 Apr 2023 09:08:45 +0900

람다와 스트림 - collect() part1

collect()란? collect()란 스트림의 최종 연산 중 하나의 과정이다. 사실 다른 최종 연산과 같이 다뤄야하나 비중이 크다보니 별도로 다룰 것이다. collect()는 간단히 말하면 다양한 콜렉션 자료들을 쉽

sgcomputer.tistory.com

지난 번에 이어서 이번에는 collect()의 여러 기능 중 하나인 분할에 대해서 공부해보자.

collect()는 스트림으로 만들어진 데이터를 쉽게 다루기 위한 메서드라고 이전 파트에서 배웠다.

하지만 이전 파트에서는 단일 스트림을 다루는 방법에 대해서만 배웠다.

이번에는 collect()를 이용해 스트림을 분할하여 나눈 데이터를 다루는 방법을 배울 것이다.

partitioningBy()와 groupingBy()

스트림을 분할하기 위해서는 크게 두 가지 방법이 있다.

바로 partitioningBy()와 groupingBy()다.

둘의 차이를 설명하자면 partitioningBy()는 스트림을 2분할, groupingBy()는 다중 분할이 가능하다.

예를 들어 한 반의 학생들을 남, 녀 둘로 나눌때는 partitioningBy()를 쓰는 것이 유리하다.

반면 한 반의 학생들을 점수별로 여러 그룹으로 나눌 때는 groupingBy()를 써야한다.

물론 groupingBy()로도 2분할을 할 순 있지만 그보단 partitioningBy()를 쓰는게 효율적이다.

partitioningBy(): 스트림의 2분할

이전 단락에서 이야기했듯 스트림을 둘로 나눌 때는 partitioningBy()를 쓰게 된다.

분할을 하는 기능은 같지만 partitioningBy()의 경우 결과 값을 반환할 때 key값으로 true, false로 반환한다.

그렇기 때문에 groupingBy()보다는 2분할을 하는데는 partitioningBy()이 적절하다.

사실 이 부분의 경우 설명보다 코드를 보는게 더 이해하기 쉽다.

partitioningBy() : 2분할 하기

우선은 위 코드를 따라하면 간단하게 2분할이 가능하다.

학생 정보를 가진 리스트의 스트림을 생성한 뒤 collect() 메서드 안에서 partitioningBy()를 사용하면 된다.

그리고나서 partitioningBy()안에는 람다식을 통해 메서드 기준을 전달하면 데이터 스트림의 분할은 끝이다.

이때 partitioningBy()의 결과는 Map의 형태 즉 key와 value의 나눠 반환된다.

key의 경우 true, false로 나뉘고 value의 경우는 학생 정보가 담긴 객체를 담은 리스트 형태로 반환된다.

앞서 이야기했듯 partitioningBy()의 경우 true, false를 key로 반환하므로 2분할에 적합하다.

그 뒤에 key값을 기준으로 학생 정보를 출력한 결과는 위와 같다.

true와 false를 기준으로 데이터가 분할된 것을 쉽게 확인할 수 있다.

partitioningBy() + coungting() : 2분할 하기 + 숫자 세기

이번에는 단순 분할 후 추가적으로 다양한 통계 기능을 이용하는 걸 실습해보자.

이전 단락에서 말했듯 collectors 클래스가 제공하는 다양한 통계 기능이 있다.

counting(), summingInt(), maxBy(), minBy() 등이 그것이다.

물론 분할을 하지 않은 스트림에서 사용 가능한 메서드도 있다.

하지만 collectors가 제공하는 메서드는 분할된 스트림에서도 사용가능한 것이 특징이다.

우선 이번 단락에서는 분할된 스트림의 갯수를 세는 counting()에 대해 알아보자.

counting() 메서드를 사용하는 것은 아주 간단한다.

이전 단락에서 partitioningBy()을 사용한 것에 추가적으로 counting() 사용을 명시해주면 끝이다.

위 코드의 경우 성별로 나눈 뒤 그 성별 숫자를 세서 반환하는 내용이다.

이때 주의 할점은 partitioningBy()이 반환하는 key값은 true, false로 반환된다.

하지만 value는 숫자로 반환된다는 점이다.

그래서 Map의 지네릭스는 <Boolean, List<Students>>에서 <Boolean, Long>으로 바꿔야 한다.

결과는 위와 같다. true를 성별로 가진 학생은 4명이고 false를 성별로 가진 학생은 3인걸 알 수 있다.

partitioningBy() + maxBy() : 2분할 하기 + 최고점자 선택

이전 단락에서 성별로 2분할 하고나서 그 분할된 학생들의 수를 세는 코드에 대해 공부해봤다.

이번에는 성별로 분할된 학생들 중 최고 점수를 가진 학생을 찾아보는 maxBy()에 대해 공부해보자.

위 코드를 딱 봤을 때 counting()과 달리 조금 복잡하다는 것을 느낄 수 있을 것이다.

maxBy()의 경우 별도의 비교 기준이 필요하므로 그걸 제공하는 과정에서 다소 코드가 길어지기 때문이다.

하지만 이 또한 분리해서 보면 크게 어려울 것도 없다.

위 코드에서 collect()의 괄호를 층위별로 색깔을 다르게 해서 나타낸 그림이다.

여기서 collect()안에서 partitioningBy()를 사용하는 것은 이전 단락들의 코드와 다를 바가 없다.

그 다음 partitioningBy() 안에서 isGender() 메서드 다음 maxBy()를 써준다.

이제 maxBy()를 쓸 때는 어떤 걸 기준으로 최고 숫자를 뽑을 지 비교 기준을 전달해야한다.

이때 Comparator 인터페이스가 제공하는 comparing() 메서드를 사용해야 한다.

그리고 나서 comparing() 메서드 안에 비교기준으로 사용할 데이터를 불러오면 된다.

위 코드의 경우 최고점을 받은 사람을 뽑는 것이므로 getScore()를 통해 각 학생들의 점수를 불러온다.

이때 한 가지 주의할 점은 maxBy()의 경우 반환 타입이 Optional이므로 지네릭스 수정이 꼭 필요하다.

위 코드의 결과는 그림과 같다.

각 성별(true/false)에서 가장 높은 점수를 받은 사람 둘을 걸러낸 것을 볼 수 있다.

partitioningBy() + partitioningBy() : 분할의 재분할

지금까지 partitioningBy()은 2분할이 가능하다고 공부했다.

하지만 실제로 partitioningBy()을 여러번 사용하면 다중 분할이 가능하다.

이번에는 partitioningBy()을 두번 사용해서 2+2 4중 분할하는 방법에 대해 알아보도록 하자.

위 코드는 학생들을 성별로 나누고 80점 이상과 이하인 경우로 나눠 스트림을 총 4개로 분할하는 코드다.

대충 보면 알겠지만 Map에서 value 안에 Map을 한번 더 써준 형태라고 생각하면 된다.

위의 코드의 구조를 그림으로 나타내면 위와 같다.

즉 Map안의 value에 Map을 하나 더 넣어서 4분할로 만들어준 것과 같다.

변수의 지네릭스를 보면 위와 같은 구조임을 확인할 수 있다.

partitioningBy()안에 기존과 마찬가지로 isgender() 메서드를 사용한 뒤 partitioningBy()를 한 번 더 쓰면 된다.

이때 안쪽의 partitioningBy()는 학생들의 점수를 받아와서 80점보다 높으면 true, 낮으면 false로 반환한다.

그리고 결과는 위와 같다.

성별로 점수별로 분류되서 출력된 것을 확인할 수 있다.

물론 다중 분할은 groupingBy()를 사용하는 것이 맞지만, 이렇게 다른 식으로 다중 분할이 가능하다.

groupingBy(): 스트림의 다중 분할

이전 단락에서는 partitioningBy()를 통해 스트림을 분할하는 방법을 배웠다.

partitioningBy()는 2분할을 기본으로 한다.

물론 다중 분할은 가능하지만, partitioningBy()를 중복으로 사용해서 분할의 분할을 하는 식이다.

그와 달리 groupingBy()은 처음부터 다중 분할이 가능하다.

이번에도 코드를 통해서 알아보자.

groupingBy() : 다중 분할하기

이전 단락에서 배운 partitioningBy()를 잘 따라왔다면 groupingBy()도 그리 어렵지 않다.

위 그림은 groupingBy()를 이용해서 반별로 분류를 한 코드를 나타낸 것이다.

스트림을 생성하고 collect()를 사용한 뒤 그 안에서 groupingBy()를 사용하면 분할은 끝난다.

이때 groupingBy()에서 어떤 데이터를 불러오느냐에 따라 분할 기준이 달라진다고 보면 된다.

해당 코드의 결과는 위 그림과 같다.

1,2,3반으로 나뉜 것을 확인할 수 있다.

groupingBy() + counting() : 다중분할 + 숫자 세기

이전 partitioningBy() 파트에서 배운 것처럼 groupingBy()에서도 counting() 사용이 가능하다.

사용 방법은 partitioningBy()와 마찬가지로 어렵지 않다.

groupingBy()안에 그냥 원하는 분류 데이터를 불러온 뒤 counting()를 사용해주면 된다.

코드의 결과는 위와 같다.

groupingBy() + maxBy() : 다중 분할 및 최고 숫자 찾기

groupingBy()를 maxBy()를 사용하는 것도 partitioningBy()에서 maxBy()를 써준 것과 사용법은 동일하다.

collect() 안에서 groupingBy()를 사용하고 그 뒤에 maxBy()를 쓰면 된다.

이때 maxBy()안에서는 Comparator 인터페이스가 제공하는 comparing()메서드를 사용한다.

그리고 comparing()안에서 학생의 점수 데이터를 불러오면 각 반별로 최고 점수가 누군지 알 수 있다.

결과는 위와 같다.

maxBy()를 사용하는건 groupingBy()나 partitioningBy()이나 동일하기에 크게 어렵지 않을 것이다.

groupingBy() : 그룹 내 조건을 주어 분할하기

이번에는 점수 별로 학생 그룹을 3분할 하는 방법을 알아보자.

사실 partitioningBy()을 이용할 때는 조건부 분할은 어렵지 않았다.

하지만 groupingBy()는 분할 그룹 수가 많아지므로 코드가 조금 복잡해진다.

코드를 보면 groupingBy() 안에 if조건문을 넣다보니 코드가 복잡해보일 뿐, 내용 자체는 어렵지 않다.

이전에 점수 데이터를 불러와 분류한 것과 달리 이번에는 if문을 넣어 점수 범위 별로 분류한 것일 뿐이다.

80점 이상을 받으면 상위, 70점 이상은 중간, 그 이하는 하위로 분류하는 코드인데

분류할 때 반환해주는 Students클래스를 만들 때 미리 작성해둔 열거형 상수를 사용한 것이다.

위의 코드를 실행한 결과는 위 그림과 같다.

내용에서 볼 수 있듯이 조건에 따라 점수별로 학생들을 3분할 한 것을 확인할 수 있다.

groupingBy() + partitioningBy() : 다중분할 내 이중 분할

이번에는 학생을 반별로 나눈 뒤 그 안에서 80점을 기준으로 학생을 재분류하는 방법을 알아보자.

이 경우에는 아주 간단하게 groupingBy() + partitioningBy() 형태로 코드를 짜주면 된다.

groupingBy()는 partitioningBy()처럼 특정 기준을 가지고 분할하려면 코드가 복잡해진다.

간단하게 분할하고자하면 이 방법을 사용하는게 나쁘지 않다.

코드가 복잡해 보일지 몰라도 이전에 배운 partitioningBy()를 groupingBy()와 함께 collect()안에 써준 것 뿐이다.

우선 groupingBy()를 통해서 학생을 반별로 분할하고 partitioningBy()으로 점수별로 분할한 것이다.

위 코드의 구조를 그림으로 나타내면 위와 같다.

우선 반별로 나누고 그 다음 해당 value안에서 true, value 둘로 나눠주는 것이다.

코드의 실행 결과는 위의 그림과 같다.

예상한대로 반별로 분할하고 점수 별로 분할한 결과물을 확인할 수 있다.

람다와 스트림 - collect() part1

ksge7 — Mon, 17 Apr 2023 06:45:23 +0900

collect()란?

collect()란 스트림의 최종 연산 중 하나의 과정이다.

사실 다른 최종 연산과 같이 다뤄야하나 비중이 크다보니 별도로 다룰 것이다.

collect()는 간단히 말하면 다양한 콜렉션 자료들을 쉽게 가공할 수 있게 도와주는 메서드다.

collect()와 collectors

collect()는 이전에 배운 reduce()가 가진 기능 뿐 아니라 더욱 다양한 기능을 가진다.

그런데 앞서 reduce()에선 직접 연산 과정을 다 적어줬다.

하지만 collect()의 경우 더욱 복잡하고 다양한 자료 가공을 하다보니 직접 적는건 힘들다.

그렇다보니 collect()를 편하게 사용하기 위해 필요한 것이 바로 collectors 클래스다.

static 클래스인 collectors는 다양한 컬렉션(데이터)를 가공할 수 있는 메서드를 가졌다.

그래서 collect()의 매개변수로 collectors가 가진 메서드를 전달하는 식으로 데이터를 쉽게 가공할 수 있다.

collect() 실습에 사용할 클래스

class Students implements Comparable{
    enum level {High, Middle, Low}

    int num;
    String name;
    boolean gender;
    int score;
    int ban;

    Students(){};
    Students(int ban, int num, String name, boolean gender, int score){
        this.ban = ban;
        this.num = num;
        this.name = name;
        this.gender = gender;
        this.score = score;
    };

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "반: "+this.ban+" 번호: "+this.num+" 이름: "+this.name+" 성별: "+this.gender+" 점수: "+this.score;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Students) {
            Students stu1 = (Students)obj;
            Students stu2 = this;
            return stu1.ban == stu1.ban && stu1.name == stu2.name && stu1.num == stu2.num && stu1.gender == stu2.gender && stu1.score == stu2.score;
        }
        return false;
    }


    public int getNum() {
        return num;
    }

    public String getName() {
        return name;
    }

    public boolean isGender() {
        return gender;
    }

    public int getScore() {
        return score;
    }

    public int getBan() {
        return ban;
    }

    @Override
    public int hashCode() {
        return Objects.hash(ban+num+name+gender+score);
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Students) {
            Students stu1 = (Students) o;
            Students stu2 = this;
            return (stu1.num)-(stu2.num);
        }
        return 0;
    }

}

public static void main(String[] args) {

        List<Students> stuList = new ArrayList<Students>();

        stuList.add(new Students(1, 5, "권오번", true, 70));
        stuList.add(new Students(2, 4, "윤사번", true, 80));
        stuList.add(new Students(3, 2, "정이번", false, 90));
        stuList.add(new Students(1, 7, "나칠번", true, 83));
        stuList.add(new Students(2, 1, "하일번", true, 88));
        stuList.add(new Students(3, 3, "정삼번", false, 75));
        stuList.add(new Students(2, 6, "차육번", false, 65));
 }

collect()의 경우 기능이 굉장히 많아서 우선 실습에 앞서 사용할 클래스를 미리 만들어두고 하는게 좋다.

해당 글은 위의 코드를 기반으로 진행할 것이다.

대략적으로 클래스를 설명하자면 학생들의 반, 번호, 이름, 성별, 시험점수를 멤버변수로 갖는 클래스다.

그리고 아래 코드는 클래스의 객체를 구현해서 학생 리스트에 넣는 코드다.

스트림을 컬렉션으로 변환 - toList(), toSet, toMap(), toCollection()

toList() : 스트림을 리스트로

우선 collect()에서 가장 많이 사용하게 되는 기능은 바로 스트림 요소를 리스트로 변환하여 전달하는 기능이다.

사용법은 위와 같다. 이전 단락에서 말한대로 스트림을 생성 후 collect()를 이용하면 된다.

이때 collect() 메서드의 인수로 collectors 클래스의 toList() 메서드를 전달하기만 하면 된다.

그렇게하면 위 그림과 같이 이름만 따로 추출한 리스트를 얻어낼 수 있다.

toSet() : 스트림을 셋으로

toSet()의 사용법은 toList()와 동일하다.

위에서 볼 수 있듯이 toSet()도 collect()의 인수로 전달되기만 하면 된다.

그리고 순서는 다르지만 중복되는 이름이없기에 List와 동일하게 이름이 출력된 것을 볼 수 있다.

toMap() : 스트림을 맵으로

toMap()의 경우 리스트, 셋보다는 조금 더 까다롭다.

그럴 수 밖에 없는게 Map의 경우 key, value 한쌍의 데이터가 필요하기 때문이다.

이 경우 toList(), toSet()과 달리 toMap()은 데이터를 toMap() 메서드 안에서 가공하게 된다.

toMap()에는 두 개의 람다식이 들어가는데, 위와 같이 원하는 객체의 자료를 람다식으로 추출하면 된다.

이 경우는 학생의 번호를 key로, 이름을 value로 만들어 Map의 형태로 반환한 것이다.

결과는 위와 같다. Map의 형태로 번호, 이름이 묶여서 출력된 것을 확인할 수 있다.

toArray() : 스트림을 배열로

스트림을 배열로 바꾸는건 collect()를 사용하는건 아니지만 배워보자.

스트림을 배열로 반환하는건 얼핏보면 collect()보다 쉬워보인다.

스트림을 만들고 바로 toArray()를 사용하면 되기 때문이다.

하지만 주의할 점이 하나 있는데, 바로 toArray()의 기본 반환 타입이 Object라는 것이다.

위 그림의 stuArr3를 보면 스트림을 배열로 만들 때는 굳이 매개변수가 필요가 없다는 것을 알 수 있다.

stuArr3를 만든 것처럼 toArray()를 통해 바로 배열 생성이 가능하다.

하지만 이렇게 매개변수 없이 배열을 생성할 경우 Object타입으로 자료를 반환한다.

그렇기때문에 별도의 처리가 필요없이 stuArr1처럼 배열의 생성자를 매개변수로 지정해두면 편하다.

이 경우 위 그림에서 볼 수 있듯 별도의 처리 없이 편리하게 배열을 만들 수 있기 때문이다.

스트림을 배열로 바꾼 결과는 위와 같다.

Student 객체가 배열에 순서대로 저장된 것을 확인할 수 있다.

스트림의 통계 구하기 - counting(), summingInt(), maxBy(), minBy()

counting(): 데이터의 갯수 구하기

사실 스트림에는 요소의 개수를 쉽게 구할 수 있는 메서드가 있다.

바로 count()다. 이건 그냥 collect()도 필요없고 스트림을 만든다면 바로 사용할 수 있다.

하지만 collector의 메서드로 등록된 counting()은 이것과는 같으면서도 다르다.

무슨 이야기냐면 count()나 counting()은 스트림의 요소 갯수를 알려준다는 기능은 동일하다.

하지만 count()가 단순히 전체 스트림 요소의 갯수만을 알려준다면

counting()은 추후 배울 그룹별로 분할된 스트림의 각 요소의 갯수까지 파악이 가능하다.

간단히 설명하면 현재 스트림의 전체 요소는 7개지만, 이걸 남녀따로 스트림 두개로 분할한다고 가정하자.

이럴 경우 counting()을 이용하면 각각 분할된 스트림의 갯수까지 파악이 가능하다.

우선 위의 코드에선 분할을 하지 않았기에 count()나 counting()의 수는 똑같이 7개다.

하지만 추후 분할을 배우면서 실행해보면 다른 결과물을 얻을 수 있다.

summingInt(): 모든 요소 더하기

summingInt()은 스트림의 요소가 가진 숫자를 모두 다 더해준다.

예를 들어 모든 학생의 총점을 구하고 싶다면 summingInt()을 사용하면 된다.

사실 counting()과 마찬가지로 summingInt()도 sum()이라는 대체 메서드가 있다.

하지만 sum()은 단순히 전체 스트림을 대상으로 숫자를 더하는 반면에

summingInt()의 경우 그룹별 분할된 스트림에서 각각 스트림 별로 숫자를 더할 수 있다.

실제로 사용해보면 sum()보다는 분할된 스트림을 이용하는 경우가 많다.

그래서 보통은 summingInt()의 활용 빈도가 높다.

maxBy(), minBy(): 최대값, 최소값 구하기

maxBy(), minBy()는 스트림의 각 요소 중 최대값과 최소값을 구할 수 있는 메서드다.

maxBy(), minBy()의 경우 조금 사용 방법이 까다롭다.

각각 매개변수로 Comparator가 가진 comparing()메서드를 전달해야하기 때문이다.

위 그림에서 볼 수 있듯이 다양한 comparing() 메서드가 존재하고 이 중 하나를 고르면 된다.

위의 코드에선 점수는 int타입이므로 comparingInt()를 선택했다.

그리고 이쯤되면 알겠지만, maxBy(), minBy()도 분할된 스트림에서 최대값, 최소값을 구할 수 있다.

즉 그룹별로 분할된 스트림 내에서 최대값, 최소값을 구할 수 있다는 것이다.

그리고 maxBy(), minBy()의 경우 반환타입이 Optional이므로 알아두도록 하자.

우선 현재 기준으로 maxBy(), minBy()의 출력 결과다.

가장 높은 점수를 가진 객체와 가장 낮은 점수 가진 객체를 알 수 있다.

스트림의 누적 연산 - reducing()

reducing()은 reduce()와 동일하게 누적 연산 기능을 한다.

하지만 차이점이라면 reduce() 전체 스트림에 대한 누적 연산 기능만을 한다면

reducing()은 분할 스트림에 대한 누적 연산이 가능하다.

일단 사용 방법은 기본적으로 reduce()와 동일하다고 보면 된다.

아직 스트림을 분할한게 아니다보니 결과물은 당연히 전체 스트림 요소의 합계다.

스트림의 요소 합치기 - joining()

joining()을 사용하면 스트림의 각 요소들을 병합할 수 있다.

위와 같이 스트림에서 이름만 추출한 다음 joining()을 이용해 매개변수로 특정 기호나 문자를 전달한다.

그러면 해당 기호, 문자를 기준으로 데이터를 병합할 수 있다.

출력 내용을 보면 위와 같이 주어진 기호를 기준으로 모든 데이터가 병합된걸 볼 수 있다.

람다와 스트림 - 최종 연산

ksge7 — Mon, 17 Apr 2023 05:40:53 +0900

스트림의 최종 연산이란?

람다와 스트림 - 스트림의 정의와 특징

스트림의 정의와 그 필요성 한마디로 말하면 컬렉션이나 배열을 다루기 쉽게 만든 것이다. 기존의 컬렉션 프레임웍을 보면 위와 같이 List, Set, Map의 인터페이스로 구성된 것을 알 수 있다. 이 중

sgcomputer.tistory.com

이전 파트에서 배웠듯이 스트림은 일반적인 객체와 달리 한번 사용하고 나면 재활용이 불가능하다고 배웠다.

그때 이 사용의 기준이 되는 것이 바로 최종 연산이다.

이전에 써먹었던 그림을 다시 가져오면 위와 스트림은 위와 같은 과정으로 사용하게 된다.

컬렉션 데이터에 대한 스트림 요소를 생성한 뒤 중간 연산을 통해 데이터를 가공한다.

그 뒤에 최종 연산 과정에서 스트림 요소를 소모하면서 스트림의 사용이 끝나게 되는 것이다.

해당 파트에서는 스트림의 다양한 최종 연산 방법에 대해 공부해보도록 하겠다.

최종 연산 - forEach() : 결과 출력

forEach()는 많은 예시에서 이미 사용했는데 스트림의 데이터들을 출력하는 기능을 한다.

forEach() 메서드는 반환 타입이 void이므로 아무것도 반환하지 않는다.

그리고 인수로는 Consumer 인터페이스 형식의 람다식만 전달 받는다.

최종 연산 - allMatch(), anyMatch(), noneMatch : 조건식 일치 여부

이번 단락에서 소개할 메서드들은 조건에 따른 결과가 일치하는지 여부를 따지는 기능을 한다.

- allMatch() : 전달된 인자가 전부 조건에 맞을 경우 true 반환.

- anyMatch() : 전달된 인자 중 하나라도 조건에 맞을 경우 true 반환.

- nonMatch() : 전달된 인자가 모두 조건에 안맞을 경우 true 반환.

위의 그림과 메서드 설명만 봐도 사용이 어려운 메서드는 아니라는 걸 알 수 있다.

세 개의 메서드 모두 boolean을 반환타입으로 갖고 있으며 인자로는 Predicate 인터페이스의 람다식을 받는다.

최종 연산 - findFirst(), findAny() : 조건식 일치 여부

- findFirst() : 조건 식에 맞는 요소들 중에서 가장 첫번째 요소 반환

- findAny() : 조건 식에 맞는 요소들 중에서 아무 요소나 하나 반환

findFirst()와 findAny()는 filter()와 같이 쓴다고 보면 편하다.

filter()를 통해서 걸러진 요소들 중 findFirst()는 첫 번째 요소를 findAny() 랜덤한 요소를 하나 반환한다.

이때 주의할 점은 findAny()는 parallelStream() 즉 병렬 스트림일 때만 제대로 작동한다.

만약 일반 직렬 스트림일 경우 findFirst()처럼 조건에 맞는 요소 중 첫번째 요소를 반환한다.

그리고 하나 더 중요한 점은 findFirst()와 findAny() 모두 반환타입이 Optional이라는 것이다.

이는 조건에 맞는 식이 하나도 없는 경우를 NullPointException을 방지하기 위함이다.

최종 연산 - reduce() : 스트림의 누적 연산을 수행

reduce는 겉보기에는 복잡해 보이지만 실은 그렇게까지 어렵진 않다.

reduce에 인수로 제공되는 수는 초기값, 스트림 요소의 연산 결과값, 스트림 요소 총 세가지다.

연산 과정을 설명하자면 다음과 같다.

- a의 초기값은 지정된 숫자 0에서 시작한다. 연산이 진행되면 a는 a+b의 값을 갖는다.

- b는 연산이 진행됨에 따라 list의 요소들을 차례로 갖는다.

- 즉 연산 과정에 따른 값의 변화는 다음과 같다.

- 0+1 = 1

- 1+2 = 3

- 3+3 = 6

- 6+4 = 10

- 10+5 = 15

표로 나타내면 위와 같다고 보면 된다.

a는 처음 연산에만 초기값을 빌려 쓰고 그 다음 연산부터는 a는 연산의 결과인 a+b의 값을 사용한다.

reduce는 이런식으로 모든 요소에 대한 누적 연산이 가능하고 이를 이용해 다양한 연산이 가능하다.

위의 그림을 통해 reduce()의 인수로 어떤 초기값과 식을 주느냐에 따라 결과는 다르게 나오는 것을 확인할 수 있다.

람다와 스트림 - Optional<T>

ksge7 — Mon, 17 Apr 2023 00:38:55 +0900

그림 1

그림 2

그림 1과 같은 코드가 있다고 가정해보자. 만약 저 상태로 실행한다면 그림 2와 같은 결과를 확인할 수 있다.

변수 nul은 null을 가지고 있기 때문이다. 그렇다면 이 코드에서 NullPointException이 발생하지 않도록 해보자.

아주 간단하게 나타나면 위와 같은 코드로 나타낼 수 있을 것이다.

물론 이건 한줄짜리 코드라 간단해보이지만 코드가 길어진다면 null체크 코드만으로도 복잡해보일 것이다.

만약 이걸 더 깔끔하게 나타내려면 어떻게 해야할까?

바로 Optional 클래스를 사용해주면 된다.

Optional<T>는 지네릭 클래스로서 모든 타입의 참조 변수를 감싸는 래퍼 클래스다.

위의 코드에서 확인해보면 알겠지만 Optional 타입의 변수가 String타입의 변수를 저장한 것을 볼 수 있다.

이를 그림으로 나타내면 위와 같을 것이다.

Optioanl 클래스는 모든 참조 변수 객체를 그림과 같이 감싸서 활용할 수 있도록 도와준다.

그런데 여기서 한 가지 의문이 든다. 단순히 if문을 간략하게 하기 위해서 Optional 클래스를 만든 것일까?

답은 아니다. 사실 Optional<T> 클래스는 null을 다루기 위해서 만들어졌다.

자바를 실습하다보면 알겠지만 NullPointException 오류를 한번쯤은 경험해봤을 것이다.

이때 이러한 null을 래퍼클래스의 형식으로 편리하게 다루기 위해 만들어진 것이 Optional 클래스다.

Optional 객체의 생성 - of(), ofNullable()

Optional 객체를 생성하기 위해선 크게 두 가지 방법이 있는데 바로 of()와 ofNullable()를 쓰는 것이다.

Optioanl은 static 클래스로서 new 연산자 없이도 객체를 사용할 수 있고 of()와 ofNullable() 바로 이용 가능하다.

그렇다면 여기서 굳이 왜 객체 생성 방법을 of()와 ofNullable() 둘로 나눴는지 의문이 들 것이다.

간단히 설명하자면 of()의 경우 null 값을 인자로 받지 않는다. 반면 ofNullable()은 null값을 인자로 받을 수 있다.

즉 코드 작성시 null값이 들어올 가능성이 있다면 ofNullable()을 사용하는 것이 좋다.

Optional 객체의 초기화

만약 코드를 작성하다가 Optioanl 객체를 초기화해야할 일이 있다면 empty()를 쓰는 것이 좋다.

empty()의 경우 위의 결과에서 볼 수 있다시피 아무값이 없는 null과 달리 문자열 출력되는 것을 볼 수 있다.

Optional 객체의 값 반환하기

이전 단락에선 Optional 객체를 생성하는 방법을 배웠다면 이제는 객체가 가진 값을 반환받는 방법을 알아보자.

Optional 객체의 값 반환과 관련된 메서드는 크게 4가지가 있다.

- get() : 단순히 객체가 가진 값을 반환

- orElse() : 객체가 가진 값이 null일 경우 인자로 전달된 값 반환

- orElseGet() : 객체가 가진 값이 null이면 인자로 전달된 람다식 반환

- orElseThrow(): 객체가 가진 값이 null일 경우 인자로 전달한 오류를 발생

사실 코드와 설명만 봐도 간단하게 내용은 다 파악이 가능할 것이다.

이때 주의할 것은 get() 메서드는 단순히 객체가 가진 값을 반환하므로 잘 쓰이지 않는다는 점이다.

무슨뜻이냐면 get()의 경우 Optioanl 객체가 가진 값을 단순하게 반환하기만 한다.

그렇기 때문에 위의 코드와 결과값처럼 결국 Optional 객체가 null값을 갖게 된다면 오류가 난다.

그럼 애초에 인자값으로 null이 안들어오게 하면 되지 않나 생각할 수 있다.

근데 생각해보면 우리는 null을 간편하게 다루기 위해 Optional 클래스를 쓰는것이다.

근데 굳이 그렇게 null값이 들어오지 않도록 처리해주는게 무슨 의미가 있을까.

차라리 위의 다른 메서드 orElse() 혹은 orElseGet()를 사용하는 것이 훨씬 낫다고 볼 수 있다.

참고로 orElseGet()의 경우는 인자로는 Supplier인터페이스의 람다식이 전달되어야 한다.

즉 입력값 없이 출력값만 있는 람다식을 인자로 주어야 한다.

Optioanl 객체 기타 활용

별로 대단한 내용은 아니지만 알아두면 편리한 메서드들이다.

- isEmpty() : 해당 메서드는 Optional 객체의 값이 비었는지 확인 하는 것. 값이 없다면 true를 반환한다.

- isPresent() : isEmpty()의 반대되는 메서드. 값이 존재하면 true를 반환한다.

- ifPresent() : 만약 Optional 객체의 값이 존재한다면 출력.

람다와 스트림 - 중간 연산 part 2

ksge7 — Mon, 13 Feb 2023 05:47:57 +0900

람다와 스트림 - 중간 연산 part 1

람다와 스트림 - 스트림의 정의와 특징 스트림의 정의와 그 필요성 한마디로 말하면 컬렉션이나 배열을 다루기 쉽게 만든 것이다. 기존의 컬렉션 프레임웍을 보면 위와 같이 List, Set, Map의 인터

sgcomputer.tistory.com

이전 글에서 우리는 스트림의 중간 연산에 대해 공부해봤다.

간단히 복습해보자면 스트림 중간 연산은 컬렉션 데이터를 쉽게 재가공하기 위해 존재한다.

그렇기에 연산 반복이 가능하고 반환 데이터의 타입이 Stream이다.

오늘은 지난 번에 이어 남은 중간 연산들에 대해 공부해보고자 한다.

중간 연산 - Map(): 스트림의 요소 변경

이전에 공부한 중간 연산 메서드 sorted(), skip() 등은 컬렉션의 데이터들을 거르거나 잘라내는 것만 가능했다.

하지만 map()의 경우는 컬렉션이 가진 데이터 즉 스트림의 요소들을 수정하는 것이 가능하다.

위 코드와 같이 map을 이용하면 데이터를 사용자 편의에 맞게 가공이 가능하다.

당연히 중간 연산이므로 위와 같이 중복 사용이 가능하다.

map()을 활용하면 단순 연산 뿐 아니라 더욱 복잡한 데이터 가공이 가능하다.

중간 연산 - peek(): 중간 연산 조회

peek( )은 간단히 말하면 forEach()처럼 메서드의 연산 결과를 조회할 때 사용한다.

forEach()와 차이점이라면 stream이 소모되지 않기 때문에 연산과 연산 사이에 넣어 결과를 확인하기에 좋다.

사실 중간 연산을 다중 반복하다보면 오류가 나는 경우가 있다.

그럴 때마다 peek()을 중간에 끼워넣어 디버깅을 할 수 있다.

위 그림을 보면 알겠지만 peek( )도 다른 중간 연산과 마찬가지로 Stream타입으로 데이터를 반환하고 있다.

그 결과 Stream이 유지된 상태로 중간 결과 조회가 가능하다.

중간연산 - flatMap( ): 평탄화 및 연산

스트림 작업을 하다보면 원하는 결과를 얻지 못하는 경우가 종종있다.

이유야 여러가지가 있겠지만 보통은 스트림 혹은 데이터들의 이중 구조로 인해 오류가 나는 경우가 많다.

예를 들어보며 알아보자.

(1) flatMap()없이 데이터 다뤄보기

그림 1

위 코드와 같이 두개의 문자열을 요소로 갖는 리스트가 있다고 가정해보자.

아마 그림으로 나타내면 그림 1과 같을 것이다.

그림 2

우리가 최종적으로 만들어야 하는 건 문자들을 단어별로 분해 후 중복을 제거한 새로운 리스트이다.

아마도 완성되면 그림 2와 같은 모습의 리스트가 완성될 것이다.

이제 스트림을 생성해서 위에서 이야기한대로 데이터를 가공해보자.

지금까지 배운 내용을 토대로 스트림을 활용해 데이터를 가공하면 위와 같은 코드가 될 것이다.

스트림을 만들고 map을 통해 문장을 자르고 중복 제거 후 리스트를 반환 후 출력한 코드다.

이제 코드에 따른 출력 내용을 확인해보자.

보시다시피 예상과는 전혀 다른 결과가 출력됐다.

이건 왜 그런걸까?

(2) 연산 과정에서 스트림의 변화

이전 단락에서 지금까지 배운 내용을 토대로 리스트를 변경하는 방법을 배워봤다.

하지만 예상과는 다르게 원하는 결과를 얻지 못했다. 왜 그랬을까?

바로 연산 과정에서 스트림의 특징을 이해하지 못했기 때문이다.

우선 처음으로 돌아가보자.

그림 3

우리는 맨 처음 그림 3과 같은 상태의 리스트를 만들었다.

이 상태에서 리스트를 스트림으로 만든다고 가정해보자.

그림 4

스트림을 생성한다면 그림 4와 스트림이 생성된다.

이제 스트림을 생성했으니 문자를 잘라보자.

그림 5

아마 문자를 이상적으로 자른다면 그림 5처럼 될 것이다.

그림 6

하지만 결과는 이미 위에서 실패해서 예상했겠지만 그림 5가 아닌 그림 6과 같이 된다.

위와 같이 코드로 검증해봐도 그림 6과 같은 상황인 것을 확인해볼 수 있을 것이다.

왜 그런걸까? 이건 현재 스트림의 구조가 원하는 연산에 맞게 제대로 동작하지 못하는 구조이기 때문이다.

그림 7

그림 7에서 보듯 리스트의 데이터를 기반으로 스트림을 생성하면 오른쪽과 같이 된다.

이 상황에서 map의 내용을 실행하면 아래의 그림 8과 같이 진행된다.

그림 8

그림 8에서 보듯이 map을 실행하면 요소가 2개가 있으므로 split()은 각각의 요소 안에서 실행된다.

즉 split()은 이뤄지지만 우리가 원하는 것과 달리 그것이 각자의 범위 안에서 개별적으로 이뤄진다는 것이다.

그림 9

만약에 우리가 원하는 대로 결과를 내려면 그림 9와 같은 상황을 만들고나서 split()이 실행되어야 할 것이다.

이건 어떻게 해야하는걸까?

(3) flatMap()의 사용

이러한 문제를 해결하는 것이 바로 flatMap()이다.

map()이 단순히 요소를 전달 받아서 연산만 하는 역할이라면,

flatMap()은 평탄화(flattening)와 연산을 같이 한다.

즉 flatMap()은 그림 9와 같이 스트림의 구조를 단순화하는 작업을 하게 만들어졌다는 것이다.

우선 결과부터 확인하고 추가적으로 더 설명하도록 하자.

flatMap()을 사용한 결과는 그림 2처럼 우리가 원하던 결과와 동일하게 나왔다.

앞서 말했듯 flatMap()은 평탄화 작업을 주목적으로 하는 메서드다.

평탄화 작업이란 이번 예시에서 사용된 것 이외의 이중 리스트, 이중 스트림 등의 요소를 단순화시켜준다.

사용법도 아주 단순하다.

flatMap()의 매개변수로 스트림을 생성해주는 Stream.of() 혹은 Stream()을 전달해주기만 하면 된다.

사실 파고 들어봐도 flamMap()의 매개변수로 왜 꼭 스트림 생성 메서드를 전달해야하는지 정확한 이유는 써있지 않지만,

추측하건데 모든 데이터를 평탄화 상태에서 작업 한 후 하나의 스트림으로 다시 묶어서 반환하기 위함인 것으로 보인다.

조금 더 간단하게 예시로 설명해보자면 위와 같이 사용하면 된다.

위 코드는 문자 배열 2개를 합친 스트림을 만들어 출력하는 예시이다.

위와 같이 그저 flatMap()안에서 그저 주어진 인수를 가지고 스트림을 생성해주면 된다.

당연히 결과는 위와 같이 A~F까지 모두 하나로 합쳐져 출력된 결과를 볼 수 있다.

지금까지의 과정에서 드는 의문이 하나가 있을 수 있다.

flatMap()은 이중 요소들의 평탄화가 가능한데, map()에서는 불가능할까?

답변만 말하자면 상황에 따라 다르겠지만 map()을 통해서도 어느 정도 가능하다.

하지만 코드가 길어지고 더 번거롭기 때문에 flatMap()을 쓰는 편이 유리하다.

참고로 map() 안에서 flatMap()에서 하듯이 스트림을 생성하면 오히려 스트림이 하나더 덧씌워진다.

위의 코드처럼 map()안에서 stream.of()로 스트림을 생성해주면 아래와 같은 결과를 볼 수 있다.

스트림 안에 오히려 스트림을 하나 더 생성한 결과를 확인할 수 있다.

정리하자면 스트림을 다루다가 중간에 오류가 난다면 스트림의 구조를 확인해보자.

스트림은 데이터가 이중으로 쌓여있다면 제대로 동작하지 못하기 때문이다.

람다와 스트림 - 중간 연산 part 1

ksge7 — Sat, 11 Feb 2023 07:08:29 +0900

람다와 스트림 - 스트림의 정의와 특징

sgcomputer.tistory.com

지난 번 람다와 스트림의 정의와 특징을 설명하면서 다음과 같은 그림을 보여준 적이 있다.

간단히 이야기하자면 컬렉션의 스트림 생성 및 연산에 관한 그림이었다.

오늘은 이중에서 중간 연산에 대해서 설명하고자 한다.

중간연산이란?

중간 연산은 컬렉션을 스트림화 한 후 사용자의 필요에 따라 스트림의 데이터들을 재가공하는 과정을 말한다.

중간 연산을 통해서 데이터를 자르거나 조건에 따라 거르거나 정렬하는 등의 다양한 작업을 할 수 있다.

물론 스트림의 취지에 맞게 기존에 배웠던 방식들보다 더 편하게 사용이 가능하다.

앞서 다른 글에서 공부한대로 스트림을 만들어준 다음 체이닝 형식으로 메서드를 사용하면 된다.

중간 연산과 최종 연산의 차이

이전 스트림의 정의와 특징에서 한번 이야기한 적 있지만 다시 한번 짚고자 한다.

연산은 연산인데 중간 연산과 최종 연산은 무엇이고 무슨 차이가 있을까?

다음은 임의의 정수가 들어간 리스트에서 요소들을 뽑아 중복을 거르고 짝수를 찾아 정렬 후 문자열을 더하는 코드다.

위 그림에서 빨간 줄이 처진 코드 부분이 전부 중간 연산이다.

보통 컬렉션을 다루다보면 한번에 자료 가공이 끝나지 않고 위와 같이 여러번 가공을 거치게 된다.

그 과정에서 메서드들 간에 필연적으로 자료를 주고받게 되고 자료 타입의 문제 등이 발생할 수 있다.

이러한 불편을 해결하고 편리하게 스트림을 사용하도록 중간 연산 메서드들을 따로 만든 것이다.

중간연산 메서드들은 가공한 데이터를 항상 Stream 타입으로 반환한다.

아래는 filter( )와 sorted( ) 메서드의 반환 타입을 체크 한 것이다. 위에서 말한대로 Stream임을 알 수 있다.

중간 연산 과정을 그림으로 나타내면 위와 같다.

이처럼 중간 연산 메서드들은 계산의 연계와 용이성을 위해 Stream 타입으로 자료를 주고 받는 것이다.

반면 최종 연산은 좀 다르다.

최종 연산은 데이터 재가공이 완료되어 말 그대로 더이상 연산을 하지 않는 최종 단계다.

그러므로 굳이 자료의 반환을 Stream으로 하지 않는다. 그래서 최종 연산은 반환 타입이 여러가지다.

해당 메서드에선 void지만 필요에 따라 다양한 자료 타입으로 반환이 가능하다.

정리하자면 중간 연산은 자료를 Stream으로 반환한다. 그리고 반복적으로 사용이 가능하다.

반면 최종 연산은 Stream이 아닌 다양한 타입으로 자료를 반환한다. 그리고 반복 사용이 불가하다.

중간 연산 - distinct( ): 중복 제거

distinct()는 중복을 제거하는 중간 연산 메서드다.

위 코드에서 확인할 수 있듯이 스트림화 된 컬렉션의 데이터에서 중복을 찾아 제거하는 역할을 한다.

중간 연산 - filter( ): 자료 걸러내기

filter()는 조건에 맞지 않는 요소를 제외하는 메서드다.

이때 filter() 메서드의 매개변수로 주어지는 조건식은 함수형 인터페이스 predicate와 연동된다.

즉 조건식을 넣으면 해당 조건에 맞는 숫자는 true, 맞지 않으면 false를 반환함.

그리고 해당 요소가 false일때 스트림 데이터에서 제외한다.

중간 연산 - limit( )과 skip ( ): 데이터 잘라내기와 건너뛰기

limit()와 skip() 모두 특정 숫자 범위를 제외하는 메서드다.

limit()는 매개변수로 주어진 숫자 이후 요소는 데이터에서 제외한다.

skip()은 반대로 주어진 숫자 이전의 요소는 모두 건너뛴다.

위의 코드를 보면 limit()는 5를 매개변수로 전달해서 첫 요소부터 5번째까지 이후의 숫자는 모두 제외됐다.

반면 skip()은 5를 매개변수로 전달해서 5번째 이전의 요소인 2,4,6,8,10은 건너뛰었다.

이걸 응용하면 skip과 limit를 결합해서 데이터를 가공하는 것도 가능하다.

위의 경우 skip으로 앞의 3개의 숫자를 건너뛰고, 그 뒤에 남은 숫자 중 3개까지만 남기고 그 뒤는 전부 제외하하는 코드다.

즉 2,4,6,8,10,12,14,16,18,20 => skip => 8,10,12,14,16,18,20 => limt => 8,10,12 와 같은 단계로 계산이 진행된다.

중간 연산 - sorted( ): 정렬하기

sorted()는 데이터를 정렬하는 중간 연산 메서드다.

위와 같이 중간 연산으로 sorted()를 사용하면 기본정렬에 맞춰 데이터를 정렬해준다.

하지만 여기서 중요한건 sorted()의 기본 정렬이 아니다.

실제로 데이터를 정렬할 때는 기본 정렬 뿐 아니라 역정렬이나 별도의 정렬 기준을 만들어야하는 경우도 있다.

그럴때는 sorted()의 매개변수에 정렬 기준이 되는 Comparator를 전달해줘야 한다.

혹시 Comparator에 대해 모른다면 아래를 참고하자.

컬렉션 - Comparable와 Comparator

Comparable와 Comparator는? 객체의 정렬에 필요한 메서드(정렬 기준 제공)을 정의한 인터페이스. Comparable은 특정 클래스의 기본 정렬 기준(디폴트)를 구현하기 위해 사용된다. 반면 Comparator는 기본 정

sgcomputer.tistory.com

우선 기본적으로 미리 만들어져있는 Comparator에 대해 알아보자.

미리 만들어진 Comparator의 종류는 많지만 우선 위의 네 가지를 가장 많이 쓴다고 보면 될 것이다.

Comparator.naturalOrder(): 기본 정렬. 이 경우엔 리스트의 요소들이 String이므로 String 기본 정렬 법칙을 따른다.

Comparator.reverseOrder(): 역정렬. 이 경우엔 String의 기본 정렬의 반대로 정렬한다.

String.CASE_INSENSITIVE_ORDER: String클래스가 제공하는 Comparator. 대소문자 구분없이 정렬.

String.CASE_INSENSITIVE_ORDER.reversed(): Comparator에 reversed() 메서드 사용. 대소문자 구분없이 역정렬.

이 정도면 아주 기본적인 자료타입을 가진 리스트들은 정렬이 가능하다.

하지만 별도의 정렬을 기준 만들어야 하는 경우엔 어떻게 할까?

중간 연산 - sorted( ): 정렬하기 + 새로운 정렬 기준 만들기

class WorldCup implements Comparable{

    String name;
    String continent;
    int round;

    WorldCup(){};

    WorldCup(String name, String continent, int round) {
        this.name = name;
        this.continent = continent;
        this.round = round;
    };

    String getName(){
        return this.name;
    }

    String getContinent(){
        return this.continent;
    }

    int getRound(){
        return this.round;
    }

    public String toString(){
        return this.continent+" : "+this.name+" : "+this.round;
    };

    @Override
    public int compareTo(Object o) {
        WorldCup country = (WorldCup) o;
        return this.name.compareTo(country.name);
    }
}

예를 들어 위와 같이 월드컵 관련 정보를 가진 객체를 만들 수 있는 클래스가 있다고 가정해보자.

이제 객체를 만들고나서 리스트에 넣은 뒤 스트림을 만들어 정렬 후 출력해보자.

국가가 이름 순으로 정렬된 출력 결과를 볼 수 있다.

이것은 클래스를 작성할 때 기본 정렬을 만드는 compareTo()의 코드를 이름 순으로 정렬하도록 작성했기 때문이다.

그렇다면 해당 객체들을 정렬할 때 다른 기준으로 정렬하고 싶다면 어떻게 해야할까?

우리가 기존에 배운 방법대로라면 Comparator 인터페이스를 구현한 클래스를 별도로 작성해야한다.

그것도 아니라면 매개변수에 직접 Comparator 인터페이스를 구현한 익명 클래스를 작성해야한다.

물론 이것이 기본적인 방법이지만 다소 번거로운 것이 사실이다.

스트림에서 데이터를 정렬할 때는 더 간단한 방법이 있다.

바로 Comparator 인터페이스가 가진 static 메서드인 comparing()을 쓰는 것이다.

comparing()은 매개변수로 비교 기준이 될 멤버들의 정보만 넘겨주면 알아서 정렬 기준을 만들어준다.

예를 들어 월드컵에 진출한 나라를 대륙별로 분류하고 싶다면 위와 같이 코드를 짜면 된다.

comparing() 메서드의 매개변수에 getContinent()로 대륙별 정보를 전달한다.

그러면 다음과 같은 결과를 얻을 수 있다.

getter를 이용해 멤버 변수들을 제공한 것만으로도 대륙별로 정렬이 된 것을 볼 수 있다.

이는 별도의 Comparator를 구현한 클래스를 만들거나 익명 클래스를 만들 필요가 없어서 굉장히 편리하다..

하지만 여기서 대륙별로 정렬하고 추가적으로 국가 이름 별로 정렬하고 싶다면 어떻게 해야할까?

그때는 compring() 메서드에 이어 thenComparing() 메서드를 이용하면 된다.

thenComparing() 메서드는 comparing()과 마찬가지로 Comparator의 static 메서드로 추가 기준을 줄 때 쓴다.

사용법은 위 그림과 같이 comparing() 코드를 작성한 뒤 체이닝으로 뒤에 바로 써주면 된다.

위 코드는 대륙별로 우선 정렬 후 그 안에서 이름 별로 정렬하는 코드로 결과는 다음과 같다.

코드를 작성한 대로 대륙별 / 이름별로 정렬된 내용을 확인할 수 있다.

이와 같이 Comparator 인터페이스의 comparing() 메서드를 잘 사용하면 편리한 정렬이 가능하다.

람다와 스트림 - 스트림 만들기

ksge7 — Tue, 9 Nov 2021 21:49:48 +0900

2021.09.15 - [백엔드/자바] - 람다와 스트림 - 스트림의 정의와 특징

람다와 스트림 - 스트림의 정의와 특징

sgcomputer.tistory.com

이전 파트에서는 스트림의 정의와 특징에 대해서 알아봤다.

간단히 복습해보자면 스트림이란 컬렉션의 데이터를 쉽게 다루기 위해 만들어진 인터페이스다.

List든 Set이든 Map이든 형태에 구애받지 않고 데이터만 뽑아서 스트림 속에 넣고 가공할 수있다.

그렇다보니 스트림은 원본 데이터에 영향을 주지 않고 데이터만 손쉽게 뽑아 가공이 가능하다.

물론 그렇게 하기 위해서는 스트림을 먼저 만들어봐야 할것이다.

컬렉션의 Stream만들기 - Stream( )

앞서 말해듯 스트림이 존재하는 가장 큰 목적을 컬렉션의 데이터를 다루기 위함이다.

그리고 컬렉션을 스트림으로 만들 때 쓰이는 가장 기본적인 메서드가 바로 Stream()이다.

사용 방법은 아주 간단하다. 위 코드와 같이 참조변수를 통해 stream() 메서드를 실행해주면 된다.

이것만으로도 stream이 생성된다. 그런데 여기서 이상한 점 하나를 찾을 수 있을 것이다.

바로 Map의 스트림 생성이다. 보시다시피 Map의 경우 메서드의 글자 색이 빨간 것을 알 수 있다. 왜그럴까?

이전 컬렉션 파트에서 설명했듯 Map의 경우 자료 구조가 List, Set와는 조금 다르다.

List와 Set이 나열구조라면 Map의 경우 키(key)와 값(value)로 나눠진 형태다.

그렇다보니 List, Set처럼 스트림을 바로 생성해줄 수 없는 것이다.

그렇다면 Map을 스트림으로 만들어주려면 어떻게해야할까? 방법은 어렵지 않다.

위의 코드처럼 Map의 Set의 형태로 만들어준다음 Stream을 생성하면 된다.

Map의 참조변수에서 entrySet(), keySet(), values() 메서드를 사용 후 체이닝으로 stream()을 실행하면 된다.

배열의 Stream 만들기 - Stream.of( ), Arrays.stream( )

이전 단락에선 컬렉션(List, Set, Map)의 데이터를 스트림으로 만드는 방법을 공부했다

하지만 데이터를 다루는건 컬렉션만 있는게 아니다.

배열 또한 데이터를 다루는 방식으로 당연히 스트림 생성이 가능하다.

배열의 스트림 생성 또한 컬렉션과 마찬가지로 어렵지 않다.

위와 같이 Stream 인터페이스의 of() 메서드 나 Arrays 클래스의 stream() 메서드를 호출하면 된다.

그런데 여기서 이상한 점을 하나 발견했을 것이다.

stream()를 사용할 때 문자열 배열과 숫자 배열을 매개변수로 제공할 때 참조변수 타입이 달라지는 것이다.

게다가 조금 더 나가면 of()와 stream()의 기능이 같다면 왜 굳이 두개로 나눠놨는지 의문이 들 것이다.

이 중에서 우선 첫번째 의문인 Arrays.stream()에 대해서 이야기해보자.

원시 타입 자료의 스트림 만들기 - Arrays.stream()

stream()을 이용해서 배열을 스트림으로 만들 때 이상한 점 한 가지를 발견했을 것이다.

바로 문자열(String) 배열과 숫자 배열을 매개변수로 줄 때 반환되는 타입이 다른 것이다.

실제로 자바 api 문서를 확인해봐도 둘의 반환 타입이 다른 것을 알 수 있다.

이러한 사실로 미뤄보아 Arrays.stream()의 경우 주어지는 인수의 타입에 따라 반환 타입도 달라짐을 알 수 있다.

그 이외에도 다양한 타입의 배열을 넣을 때마다 반환 타입이 다른 것을 확인이 가능하다.

이처럼 Arrays.stream()은 배열 그 중에서도 원시 타입 숫자 배열의 스트림에 특화되어있음을 알 수 있다.

그렇다면 왜 굳이 이렇게 원시타입을 특화했어야했을까?

바로 원시 타입 배열 숫자들의 계산을 쉽게 도와주는 메서드가 따로 존재하기 때문이다.

Arrays.stream()을 통해 원시타입 숫자배열을 스트림화하면 일반 방법보다 훨씬 편리하게 이용이 가능하다.

결론만 말하면 원시타입 숫자 배열으로 스트림 생성시 Arrays.stream()을 쓰는 것이 유리하다.

Stream.of()의 사용

앞서 Arrays.stream()가 원시 타입 배열의 스트림 생성에 특화되있다고 설명한 바있다.

이게 바로 Stream.of()와 Arrays.stream()의 가장 큰 차이다.

근데 Arrays.stream()의 경우 원시타입 뿐 아니라 일반 String 배열도 다룰 수 있다.

그렇다보면 Stream.of()이 왜 필요한지 의문이 들 수 있다.

예를 들어 위와 같이 두개의 문자열 배열이 있다고 가정해보자.

스트림을 이용해 이 두 개의 배열을 하나로 합치려면 어떻게 해야할까?

그럴 때 바로 Stream.of( ) 메서드를 사용하면 된다.

Stream.of ( )의 가장 큰 특징은 바로 가변 인자 즉 메서드의 매개변수를 여러개 받을 수 있다는 것이다.

자바의 API 문서를 봐도 여러 개의 매개변수를 받을 수 있음을 알 수 있다.

이처럼 Stream.of()는 배열 뿐 아니라 리스트 등의 스트림을 합치는데도 이용된다.

그래서 만약 두 개 이상의 의 컬렉션이나 배열을 합칠 경우 Stream.of()를 사용하면 된다.

임의의 수(랜덤값)로 스트림 만들기

코드를 작성하다보면 임의의 수를 다룰 때가 있다.

그럴때는 위 코드처럼 랜덤 클래스의 객체를 생성 후 각 기본 타입별의 스트림을 반환하는 메서드를 사용하면 된다.

Random클래스의 객체를 생성한 뒤에 체이닝으로 붙는 메서드들은 다음과 같은 의미를 갖는다.

ints( ): int를 타입으로 하는 숫자를 무한하게 만드는 스트림을 반환

longs( ): long을 타입으로 하는 숫자를 무한하게 만드는 스트림을 반환

doubles( ): double를 타입으로 하는 숫자를 무한하게 만드는 스트림을 반환

이때 주의할 점은 ints()를 그냥 사용하면 말그대로 무한 스트림이므로 사이즈를 제한할 필요가 있다.

사이즈를 제한하는 방법은 두 가지다.

가장 간단한 방법은 위처럼 매개변수로 임의의 정수를 제공하는 것이다.

이렇게 할 경우 처음 스트림을 반환할 때부터 제한된 사이즈의 스트림을 제공한다.

두번째 방법은 무한스트림을 반환받은 다음 limit() 메서드를 사용하는 것이다.

그리고 한 가지 더 만약 임의의 숫자를 출력할 때 범위를 지정하고 싶을 때는 아래와 같이 하면 된다.

위와 같이 랜덤 숫자 생성 메서드 안에 매개변수로 임의의 수를 제공하면 된다.

왼쪽 가장 첫번째 숫자는 스트림의 크기, 그 다음은 처음 수, 그 다음은 마지막 수다.

여기서는 1, 1, 10을 넣었으므로 1~10 범위 사이에서 1개의 숫자를 랜덤하게 출력하게 만드는 스트림을 반환한다.

특정 범위의 정수를 요소로 갖는 스트림 생성

특정 범위의 숫자를 모두 요소로 갖는 스트림을 생성하고 싶다면 range( ), rangeClosed( )를 쓰면 된다.

range()와 rangeClosed()의 매개 변수로 두 숫자를 입력하면 범위 안의 요소를 모두 갖는 스트림이 완성된다.

이때 range()와 rangeClosed()의 차이는 두번째 숫자를 범위 안에 넣느냐 마느냐의 차이다.

위의 코드를 보면 range()와 rangeClosed()는 각각 1,5를 매개변수로 전달했다.

이때 range()는 1,2,3,4만 요소로 갖는데 반해 rangeClosed()는 1,2,3,4,5를 요소로 갖는 것을 볼 수 있다.

즉 range()는 마지막 숫자를 제외한 범위, rangeClosed()는 마지막 숫자를 포함한 범위의 스트림을 만든다.

특정한 값만 골라서 요소로 갖는 무한 스트림 생성

지금까지 컬렉션과 배열 스트림, 랜덤 무한 스트림, 특정 범위를 갖는 무한 스트림을 만드는 것을 배웠다.

하지만 가끔은 단순히 랜덤이나 특정 범위의 숫자 뿐 아니라 특정 조건을 가진 값을 갖는 스트림이 필요하기도 하다.

그럴 때는 위와 같이 iterate()와 generate()를 사용하면 된다.

iterate()는 매개변수로 초기값(seed)와 람다식(UnaryOperator)를 제공하면 그에 맞는 숫자를 생성한 스트림을 반환한다.

위의 코드를 보면 람다식으로 초기값으로 숫자 0을 제공하고 람다식으로는 매개변수로 전달된 수에 3을 더하도록했다.

결과는 어떨까?

시드값을 기준으로 매번 3을 더하는 숫자를 모두 요소로 갖는 스트림이 생성됨을 볼 수 있다.

대략 정리하면 위와 같다.

처음 준 시드값을 람다식(UnaryOperator)의 매개변수로 제공하고 그에 따라 반환된 값을 요소로 저장한다.

그리고 이 반환된 값을 시드값 삼아 계속 무한하게 숫자가 생성된다.

generate()도 iterate()와 비슷하게 람다식을 제공하지만, 기능은 전혀 다르다.

우선 위 코드에 따른 generate()의 결과값부터 보도록 하자.

generate()는 iterate()와 달리 그저 같은 숫자를 반복할 뿐이다.

generate()에 제공되는 람다식은 iterate()의 람다식과는 다른 인터페이스이므로 반환값도 다르다.

generate()에는 iterate()와 달리 supplier 인터페이스의 람다식을 매개변수로 제공해야한다.

즉 매개변수가 없이 어떤 특정값을 생성하는 supplier의 특성으로 반환값이 저렇게 된 것이다.

빈 스트림 만들기

자주는 아니더라도 텅텅 빈 스트림을 만드는 일도 있을 것이다.

그럴 때는 위와 같이 empty() 메서드를 이용하면 된다.

람다와 스트림 - 스트림의 정의와 특징

ksge7 — Wed, 15 Sep 2021 00:24:37 +0900

스트림의 정의와 그 필요성

한마디로 말하면 컬렉션이나 배열을 다루기 쉽게 만든 것이다.

기존의 컬렉션 프레임웍을 보면 위와 같이 List, Set, Map의 인터페이스로 구성된 것을 알 수 있다.

이 중에서 List와 Set은 사용법이 비슷하지만, Map은 그 성격이 다르다.

이는 즉 컬렉션을 다룰 때 List, Set과 달리 Map을 다루기 위한 방법 또한 다르단 것을 의미한다.

스트림은 이러한 불편함을 해소하고자 만들어졌다.

스트림은 데이터 소스를 추상화하고, 데이터를 다루는데 필요한 메서드들을 정의한 인터페이스다.

예시를 한번 보도록 하자.

예를 들어 위와 같이 1부터 5까지 숫자를 가진 배열과 리스트가 있다고 가정해보자.

이제 이 배열과 리스트 중에서 짝수만 출력하려면 어떻게 해야할까?

일반적으로는 위와 같은 방식으로 짝수를 걸러내게 될 것이다.

이게 가장 간단하고 코딩 교육 초기에 배우는 방식이다.

그런데 이전에 람다와 function패키지에 대해서 배우고나서 다시 보면 저 코드들이 산만해보일 것이다.

그럴때 스트림을 써주면 된다.

위 코드는 이전과 같은 기능을 하는 코드다.

다만 스트림을 이용했기 때문에 줄줄이 늘어놓는 코드에 비해서 훨씬 간단하게 표현한 것이 특징이다.

스트림은 처음 보기에는 어려워보일지 몰라도 익히기만하면 코드를 훨씬 간결하게 표현이 가능하다.

스트림의 생성과 흐름

스트림은 이전 단락에서 말했듯이 컬렉션, 배열을 쉽게 다루기 위한 인터페이스라고 말한바 있다.

즉 컬렉션, 배열을 스트림으로 만들어서 미리 정의된 메서드를 이용해 데이터를 다루는 것이다.

그림으로 흐름을 나타내면 아래와 같다.

우선 컬렉션에 해당하는 List, Set, Map와 배열을 스트림으로 생성이 가능하다.

그 다음 생성된 스트림을 이용해 중간 연산을 진행한다.

마지막으로 최종 연산을 진행하면 스트림 사용이 완료된다.

이때 스트림을 만드는 것은 여러 데이터 형식을 하나로 표준화한다는 의미로

스트림으로 만들고나면 스트림 인터페이스에 정의된 메서드를 사용할 수 있다.

이때 기억하면 좋을 점은 중간 연산은 여러번 가능하고, 최종 연산은 단 한번만 가능하다는 것이다.

식으로 직접 보면 더 이해가 편할 것이다.

위 내용을 보면 알겠지만 스트림을 생성하고 체이닝으로 각종 연산을 한번에 수행하는 것을 볼 수 있다.

이때 sorted(), limit(), distinct()는 중간 연산 메서드로서 그 연산 결과가 스트림이다.

그래서 연산의 결과로 스트림을 서로 넘겨주며 여러 차례 중간 연산 메서드 이용이 가능하다.

하지만 최종 연산 메서드에 해당되는 forEach()의 경우 연산 결과는 스트림이 아니다.

추후 배우겠지만 모든 스트림은 iterator처럼 일회용인데,

최종 연산은 그 결과가 스트림이 아니므로 최종 연산 메서드를 사용하면 해당 스트림은 더이상 쓸 수 없다.

스트림의 특징

1. 스트림은 데이터 소스를 변경하지 않는다.

기존 배열이나 컬렉션 데이터를 스트림으로 변환하더라도 원본 데이터는 변경되지 않는다.

위의 코드를 보면 배열 중 짝수만 따로 출력을 하더라도, 배열이 변경되지 않는 것을 확인할 수 있다.

2. 스트림은 일회용이다.

스트림은 일회용이다. 이전에 Iterator에 대해 배웠다면 그와 비슷한 개념이라 생각하면 된다.

위의 코드처럼 배열을 스트림으로 만들어서 최종연산 메서드인 forEach()를 사용했다면

그 다음 다시 스트림을 쓸 때 오류가 나는 것을 알 수 있다.

이때 스트림이 사용 종료 여부는 최종 연산 메서드를 쓰느냐 안쓰느냐에 달렸다.

스트림은 일회용으로서 한번 소모하고 나면 다신 사용이 불가능하므로 새로 생성해야 한다.

만약 스트림은 재사용하고 싶다면 위 코드처럼 스트림을 재생성해주기만하면 된다.

어렵지도 않고 그냥 연산을 한번 끝마친 스트림은 재생성해서 사용해준다고 기억해두면 된다.

3. 스트림의 연산은 최종 연산이 수행되기 전까지 중간 연산이 수행되지 않는다.

위 코드는 로또 번호를 추출하는 코드다.

참고로 distinct()는 중복제거, limit()는 주어진 숫자만큼 요소 추출, sorted()는 정렬하는 중간 연산 메서드다.

이때 주의해서 봐야할 것은 바로 가장 처음 선언한 난수를 생성하는 무한 스트림이다.

이 무한 스트림은 1~45까지의 정수를 무한하게 생성하는 스트림으로서 무한히 정수를 생성해낸다.

그런데 아래 스트림의 중간 연산을 보면 무한 생성 정수의 중복을 제거하고 정렬을 하는 것을 볼 수 있다.

어떻게 무한하게 생성되는 정수를 그렇게 중복제거하고 정렬을 할 수 있을까?

이는 바로 스트림의 특징 중 하나인 지연 연산때문이다.

스트림은 효율성을 이유로 중간 연산이 있을 경우 매번 연산하지 않고, 최종 연산에 다다르면

그제서야 이전까지 있던 중간 연산을 한 번에 진행하는 것이다.

람다와 스트림 - 메소드 참조(method reference)

ksge7 — Tue, 14 Sep 2021 22:35:35 +0900

이전에 여러 파트에서 언급했듯이 위와 같이 람다식을 사용하면 메서드를 간단하게 표현이 가능하다.

물론 사용에 제한이 있긴하지만 그럼에도 불구하고 람다식은 그 효율성이 높다.

하지만 그럼에도 불구하고 이 람다식을 더 줄일 수 있는 방법이 있으니 바로 메소드 참조다.

위 코드는 문자열을 매개변수로 받아 정수형으로 반환하는 Function 참조변수를 표현하고 있다.

Function 참조 변수는 람다식으로 이뤄져 굉장히 간략하게 식을 표현하고 있다.

하지만 이런 경우 메소드 참조를 이용하면 람다식을 더욱 간략하게 표현이 가능하다.

메서드 참조를 적용하면 첫번째 코드를 위와 같이 변경이 가능하다.

람다식이 단 하나의 메소드만 호출할 경우에 해당 람다식에서 불필요한 매개변수를 없앤다.

그리고 '클래스명::메서드명'의 형태로 써주면 람다식을 더욱 간략하게 메소드 참조로 바꿀 수 있다.

위 코드처럼 매개변수가 두개인 경우도 당연히 메서드 참조로 표현이 가능하다.

위 코드의 경우 String 클래스의 equals 메서드를 메서드 참조 형태로 불러온 것이다.

참조변수를 선언할 때 지네릭스 타입을 메서드 타입에 잘 맞게 설정만해준다면

그리고 해당 람다식이 하나의 메서드만 호출하는 경우에 위와 같이 편리하게 메소드 참조 사용이 가능하다.

이전에 봤던 static메서드들은 '클래스명::메서드명'과 같은 형태로 메서드 참조를 했다.

이는 특정 객체의 인스턴스 메서드에서도 사용이 가능하다.

다만 위와 같이 이때는 클래스명이 아닌 '참조변수명::메서드'으로 메서드 참조가 가능하다.

생성자와 메서드 참조

이전에 말했듯이 메서드 참조는 람다식보다 더 간단하게 메서드를 정의하는 것을 말한다.

'클래스명::메서드명' 혹은 '참조변수명::메서드명'의 형태로 불러오게 된다.

그런데 이러한 메서드 참조는 생성자 메서드와도 함께 쓸 수 있다.

예를 들어 MethodTest라는 클래스가 있다고 가정해보자.

기존에는 MethodTest의 객체를 생성해서 이름을 입력하고 출력하려면

new 명령어를 이용해 객체를 생성해 매번 참조변수에 저장해줘야 했다.

그런데 이렇게 생성자를 호출하는 경우에도 메서드 참조가 가능하다.

ft1은 기존에 람다식 형태로 생성자를 호출한 방식이고,

ft2는 메서드 참조를 이용해 생성자를 호출한 것이다.

ft2의 경우 f1과 결과는 동일하지만 생성자 참조를 활용해서 그 내용을 더 간략하게 표현한 것이다.

그리고 위 코드는 생성자를 호출할 때 문자열을 필수적으로 넣어야하므로 Function의 참조변수를 썼다.

만약 본인이 만든 코드가 별도의 매개변수가 필요없다면 Function대신 Supplier를 써도 상관없다.

메소드 참조와 배열 생성

메소드 참조를 사용하면 배열을 만들때도 편리하게 만드는 것이 가능하다.

위 코드를 보면 쉽게 이해할 수 있을 것이다.

intArr1 배열의 경우 우리가 일반적으로 만들어주는 방식을 통해 만든 배열이다

intArr2 배열은 람다식을 이용한 Function의 참조변수 ft1을 이용해 만든 배열이다.

intArr3 배열은 메서드 참조를 이용한 Function의 참조변수 ft2를 이용해 만든 배열이다.

이처럼 람다식이 호출하는 메서드가 단 하나라면 일반 메서드 뿐 아니라 생성자, 배열 등도

메서드 참조를 통해서 표현이 가능하다.

람다와 스트림 - 컬렉션과 함수형 인터페이스

ksge7 — Wed, 1 Sep 2021 19:38:56 +0900

JDK 1.8부터는 함수형 인터페이스가 추가됐고, 그와 더불어 컬렉션 프레임웍을 편하게 사용할 수 있도록

컬렉션의 인터페이스에 디폴트 메서드가 추가됐다.

그 중 일부는 함수형 인터페이스를 사용하는데 이번 파트에서 그러한 메서드들에 대해 설명한다.

인터페이스	메서드	설명
Collection	boolean removeIf(Predicate<E> filter)	조건에 맞는 요소 삭제
List	void replaceAll(UnaryOperator<E> operator)	모든 요소를 변환하여 대체
Iterable	void forEach(Consumer<T> action)	모든 요소에 작업 action을 수행
Map	V compute(K key, BiFunction<K,V,V> f)	지정된 키의 값에 작업 f를 수행
	V computeIfAbsent(K key, BiFunction<K,V> f)	키가 없으면, 작업 f 수행 후 추가
	V computeIfPresent(K key, BiFunction<K,V,V> f)	지정된 키가 있을 때, 작업 f 수행
	V merge(K key, V value, BiFunction<V,V,V> f)	모든 요소에 병합 작업 f를 수행
	void forEach(BiConsume<K,V> action)	모든 요소에 작업 action 수행
	void replaceAll(BiConsume<K,V,V> f)	모든 요소에 치환 작업 f를 수행

Collection - removeIf()

removeIf()는 조건에 맞는 요소를 컬렉션 내에서 지우는 역할을 한다.

removeIf()는 Predicate의 참조 변수를 받아서 참조변수가 저장한 조건에 맞게 요소를 거른다.

기존에 if()문을 쓰는 것보다 훨씬 코드도 짧아지고 편리하다.

물론 위의 코드도 람다식을 쓰면 아래와 같이 더 간단히 표현이 가능하다.

removeIf() 안에는 Predicate의 참조변수가 들어가야된다.

그래서 첫 코드와 달리 아예 매개변수로 람다식을 전달해주면 형식만 맞는다면

알아서 Predicate 인터페이스와 매칭되어 코드가 정상적으로 잘 작동한다.

List - replaceAll()

replaceAll()은 단항 연산을 하는 UnaryOperator의 참조변수를 매개변수로 전달하면

내용에 맞춰 리스트의 모든 요소에 해당 참조변수의 연산 작업을 수행한다.

이해가 안된다면 위의 코드를 보도록 하자.

UnaryOperator의 참조변수는 전달받은 매개변수에 10을 더하는 연산을 시행한다.

이 참조변수를 replaceAll()에 매개변수로 전달하면 리스트의 모든 요소에 10을 더한다.

그리고 removeIf()에서 했던 것과 같이 간략하게 람다식을 전달해도 잘 작동한다.

Iterable - forEach()

forEach()는 Consumer 참조변수를 전달 받아 각 요소에 작업을 수행하는 역할을 한다.

이것만 보면 replaceAll()과 비슷해 보인다.

하지만 참조변수가 Consumer이므로 반환값이 없다는 것을 알고 사용해야 한다.

물론 forEach()도 다른 메서드들과 마찬가지로 람다식을 매개변수로 전달할 수 있다.

그리고 forEach()는 리스트 뿐 아니라 Map을 사용할 때도 유용하다.

위와 같이 forEach()를 사용하면 key와 value를 쉽게 출력할 수 있기 때문이다.

Map - compute()

Compute()는 Map에서 value의 값을 바꿀 때 사용하는 메서드다.

매개변수로 전달된 key가 Map에 존재하면 그 key에 저장된 value를 수정할 수 있게 도와준다.

위의 코드처럼 key가 map에 존재한다면 거기에 저장된 value를 원하는대로 바꿀 수 있다.

물론 위와 같이 compute() 메서드안에 바로 람다식을 전달하는 방법도 있다.

만약 여러 개의 key의 value를 변경하고 싶다면 위와 같이 만들어줄 수도 있다.

forEach()를 통해 map의 각 요소들을 순서대로 꺼낸다고 가정했을 때,

이때 제공되는 key를 compute()에 key로 전달하는 것이다.

그렇게하면 일일이 key를 입력해줄 필요없이 편리하게 value를 변경할 수 있다.

그리고 마지막으로 value의 값을 매번 다른 값으로 바꾸고 싶다면 위와 같이 해도 된다.

forEach()가 key를 순서대로 제공할 때 key를 받는다.

그리고 그 key를 인덱스 넘버로 사용해 list에서 값을 꺼내와서 value를 변경할 수도 있다.

Map - computeIfAbsent()

computeIfAbsent()는 만약 제공된 key가 Map안에 없을 때,

새로운 key를 만들고 그 안에 Function 참조변수의 반환값을 저장하는 역할을 한다.

위 코드의 경우 4가 없기 때문에 4를 key로 하여 value에는 Function의 반환값을 저장했다.

그 다음 해당 key:value를 map에 추가했다.

만약 computeIfAbsent()에 제공된 key가 map 안에 있을 경우에는 어떤 작업도 수행하지 않는다.

Map - computeIfPresent()

computeIfPresent()는 만약 제공된 key가 map에 있다면,

key에 해당하는 value에 BiFunction의 작업을 수행하는 것이다.

이것만 보면 compute()와는 별 차이가 없어 보인다.

왜냐하면 compute()도 제공된 key가 map안에 있다면

key에 해당하는 value에 BiFuntion의 작업을 수행하기 때문이다.

그런데 둘은 아주 큰 차이가 하나 있다 바로 key가 map에 존재하지 않을 때다.

우선 compute()를 다시 한번 실행해보자.

위 상황에서 compute()에 4를 key로 전달했다. 그런데 4는 Map안에 존재하지 않는다.

그럴때 compute()는 새로운 key인 4를 만들어서 BiFunction의 반환값을 value로 저장한다.

오히려 이런 점을 보면 compute()는 computeIfAbsent()과 비슷해 보인다.

하지만 compute()는 key가 map안에 존재하든 안하든 BiFunction을 실행하여 값을 Map에 저장한다.

반면 computeIfAbsent()는 key가 map안에 존재할 경우 Function을 수행하지 않는다.

이제 다시 computeIfPresent()로 돌아와서 보면 compute()와 차이를 알 수 있다.

compute()는 제공된 key가 Map 안에 없을 때 새로운 key과 value를 만든다.

하지만 computeIfPresent()는 제공된 key가 Map 안에 없으면 동작하지 않음을 알 수 있다.

Map - merge()

merge()는 기존에 key에 저장되있던 value를 변경하는 기능을 수행한다.

merge()에 key와 특정 값을 매개변수로 제공하면,

key의 value와 특정 값이 BiFuntion의 매개변수로 전달된다.

그리고 BiFunction을 거친 반환값은 처음에 merge()에 제공한 key의 value에 저장된다.

내용 이해가 힘들다면 아래의 흐름도를 보도록 하자.

이전 코드와 같은 코드인데 이번엔 코드의 흐름을 그려봤다.

이전에 설명한 것처럼 merge()에 주어진 key의 value와 제공한 특정 값을 BiFunction에 전달된다.

그리고 BiFunction은 두 숫자를 매개변수로 받아서 합쳐서 반환한다.

그리고 merge()는 BiFunction이 반환한 숫자를 처음 제공한 key가 가진 value에 새로 저장한다.

이제 대충 설명을 보면 어떤 식으로 흐름이 전개되는 지는 알 수 있을 것이다.

하지만 뭔가 의문이 들 것이다. 쓸데없이 메서드의 구조가 복잡하다는 것이다.

그리고 이렇게 할거라면 다른 메서드를 사용하는 것이 더 편해보일 수 있다.

왜 그럴까?

merge()는 흔히 두 개의 Map의 값을 합쳐서 계산하는데 쓰이기 때문이다.

일반적으로 위와 같은 용도로 쓰인다.

설명하자면, map1의 key를 순서대로 받아서 merge()에 전달한다.

그리고 나서 map1의 key의 value와 map2의 key의 value를 BiFunction으로 전달한다.

그리고나서 BiFunction에서 두 값을 합치고 merge()는 이 반환값을 map1의 key의 value에 저장한다.

흐름이 이해가 안간다면 아래 흐름도를 보도록 하자.

map1의 key가 순서대로 merge()에 전달된다.

해당 key의 value와 map2에서 해당 key와 동일한 key의 value가 BiFunction으로 전달된다.

BiFunction은 두 value를 받아서 더하고 반환한다.

merge()는 반환 받은 값을 map1으로부터 받은 key의 value에 저장한다.

그렇게 더하다보면 '100+50 -> 150' , '200+100 -> 300', '300+150- > 450' 순서로 계산된다.

그리고 최종적으로 map1의 값은 150, 300, 450이 된다.

즉 이런 식으로 map1과 map2의 value가 합쳐진 것이다.

그리고 당연히 merge() 안에 들어가는 BiFunction을 람다로 변경이 가능하다.

위 코드와 같이 한 줄로 간략하게 표현이 가능하다.

Map - replaceAll()

replaceAll()은 컬렉션의 모든 요소를 순회하며 미리 BiFunction 매개변수에 지정한 동작을 실행한다.

위의 예시의 경우 map의 key값을 순회하며 value값을 변경해주는 코드다.

미리 BiFunction에 map의 key, value를 매개변수로 전달받아 어떻게 동작할지 지정한다.

그리고 이 BiFunction의 참조변수를 replaceAll()의 매개변수로 전달하면 위와 같이 작동한다.

그리고 당연히 BiFunction 참조변수의 값을 람다식으로 replaceAll()에 전달해도 작동한다.