[Java] Stream API -3 이해하기: Stream 최종연산

 

반응형

 

 

 

 

해당 글의 목적은 Stream API를 이해하고 예제를 통한 이해를 돕기 위해 작성한 글입니다. 주된 내용은 이전에 작성한 Stream 생성을 기반으로 Stream의 중간연산인 조작을 한뒤에 최종연산으로 값을 도출해 내기 위한 최종연산에 대한 메서드에 대해서 이해합니다. 해당 글에서는 모든 함수에 대해서는 포함하고 있지 않으며 자주 사용되는 메서드 위주로 작성하였습니다.

 
 

 

💡 해당 글을 읽으시기 이전에 Stream에 대한 용어와 Stream을 생성하는 글과 Stream의 중간연산 메서드에 대해서 이해하고 읽으시면 더욱 도움이 많이 될것입니다.

 

[Java] Stream API -1 이해하기: 용어 및 Stream 생성

[Java] Stream API -2 이해하기: Stream 중간 연산

 
 

1) Stream의 구성과정

---

💡 Stream의 객체를 구성하고자 할 때 "Stream 생성 → 중간 연산→ 최종 연산" 해당 글에서 과정은 “최종 연산” 부분에 해당됩니다.

// 객체의 Stream을 생성하고 중간 연산을 수행하고 최종 연산을 하여 결과값을 얻습니다.
객체.Stream생성().중간연산.최종연산()

 
 
 
 

2) Stream 최종연산

---

 

1. 요약

---

분류	상세 분류	설명
요소의 출력	forEach()	- forEach()는 배열 혹은 리스트 내에서 순회를 하며 요소에 대한 값을 얻어서 요소에 대한 출력 혹은 값을 새로운 형태로 변환하여 구성을 하기 위한 목적으로 사용이 됩니다.
요소의 검색	findFirst(), findAny()	- findFirst()는 스트림 내에서 조건에 “일치하는 요소들 중”에서 “가장 앞에 있는 요소”를 리턴해주는데 사용되는 함수입니다. - findAny()는 스트림 내에서 조건에 “일치하는 요소들 중”에서 “먼저 탐색되는 요소”를 리턴해주는데 사용하는 함수입니다.
요소의 검사	anyMatch(), allMatch(), noneMatch()	- anyMatch()는 스트림 내의 요소들 중 주어진 조건에 맞는 요소가 “하나 라도 맞는다면” true의 값을 반환해주는데 사용하는 함수입니다. - allMatch()는 스트림 내의 요소들 중 “모두 해당 조건에 맞는지”에 대해 판단하여 모두 맞으면 true 값을 반환해주는데 사용하는 함수입니다. - noneMatch()는 스트림 내의 요소들 중 “주어진 조건에 맞는 요소가 없는지”에 대해 판단하여 모두 없다면 true 값을 반환해주는데 사용하는 함수입니다.
요소의 통계	count(), min(), max()	- count()는 스트림 내의 요소들 중 총 요소의 개수를 반환해주는데 사용하는 함수입니다. - min()는 스트림 내의 요소들 중 “가장 작은 값”을 반환해주는데 사용하는 함수입니다. - max()는 스트림 내의 요소들 중 “가장 큰 값”을 반환해주는데 사용하는 함수입니다.
요소의 연산	sum(), average()	- sum()은 스트림 내의 모든 요소들을 더하여 하나의 값으로 반환해주는 함수입니다. - average()는 스트림 내의 요소들의 평균 값을 계산해주어 하나의 값으로 반환해주는 함수입니다.
요소의 수집	collect()	- collect()는 스트림 내의 모든 요소들을 수집하여 사용자가 원하는 형태로 변환하는데 사용하는 메소드입니다.

 
 

3) Stream 중간연산 상세

---

1. 요소의 출력 : forEach()

---

💡 해당 메서드는 배열 혹은 리스트 내에서 순회를 하며 요소에 대한 값을 얻어서 요소에 대한 출력 혹은 값을 새로운 형태로 변환하여 구성을 하기 위한 목적으로 사용이 됩니다. (map, filter와 같은 순회 함수와 다르게 반환값이 존재하지 않습니다.)

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] forEachIntArr = {1000, 2000, 3000, 5000};

// 2. ArrayList Initialize
List<Integer> forEachIntList = new ArrayList<>();

// 3. 요소 값을 기반으로 새로운 배열리스트의 재 구성 : 3000 이하의 요소들을 배열에 추가합니다.
Arrays.stream(forEachIntArr).forEach(i -> {
    if (i <= 3000) {
        forEachIntList.add(i);
    }
});

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> forEachListArr = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung"));

// 2. forEach 문을 이용하여서 요소값에 대한 출력 - 1
forEachListArr.stream().forEach(System.out::println);

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> forEachUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build()
);

// 2. forEach 문을 이용하여서 요소값에 대한 출력 - 2
forEachUserDtoList.stream().forEach(i -> System.out.println(i.getUserNm()));

 
 

[참고] Stream 반복문의 종류와 사용처에 대한 비교

반복문	종류	분류	설명	주된 사용처
map()	중간 연산	반환값 존재	- map()은 구성한 스트림 내에서 요소들을 원하는 값으로 변환하여서 반환하기 위해 사용됩니다.	배열 내의 요소들을 조작하여 값들을 배열로 반환받기 위한 용도로 주로 사용됩니다.
filter()	중간 연산	반환값 존재	- filter()는 구성한 스트림 내에서 특정 조건에 맞는 결과값을 필터링하기 위해 사용됩니다.	배열 내의 요소들을 조작하여 값들을 배열로 반환받기 위한 용도로 주로 사용됩니다.
forEach()	최종 연산	void	- forEach()는 배열 혹은 리스트 내에서 순회를 하며 요소에 대한 값을 얻어서 요소에 대한 출력 혹은 값을 새로운 형태로 변환하여 구성을 하기 위한 목적으로 사용이 됩니다.	배열 내의 요소들을 조작하여 값들을 추출하여 새로운 다른 형태로 사용하기 위한 용도로 사용된다.

 
 

[참고] Collection forEach vs Stream ForEach

https://www.baeldung.com/java-collection-stream-foreach
 
 
 

2. 요소의 검색: findFirst()

---

💡 해당 메서드는 스트림 내에서 조건에 “일치하는 요소들 중”에서 “가장 앞에 있는 요소”를 리턴해주는데 사용되는 함수입니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] findFirstArr = {1000, 2000, 3000, 5000};

// 2. Array To OptionalInt
OptionalInt findFirstOptionalInt = Arrays.stream(findFirstArr).findFirst();

// 3. OptionalInt to Int
int findFirstArrInt = findFirstOptionalInt.getAsInt();  // 1000

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> findFirstArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Optional<String> : j로 시작하는 단어의 첫번째 요소를 반환합니다.
Optional<String> findFirstOptionalStr = findFirstArrList.stream().filter(i -> i.startsWith("j")).findFirst();

// 3. Optional<String> to String
String findFirstArrStr = findFirstOptionalStr.get();

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> findFirstUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Optional<UserDto> : 사용자 아이디가 "a"로 시작한 값에 대한 첫번째 객체를 반환합니다.
Optional<UserDto> findFirstOptionalList = findFirstUserDtoList.stream().filter(item -> item.getUserId().startsWith("a")).findFirst();

// 3. Optional<UserDto> to UserDto
UserDto findFirstStr2 = findFirstOptionalList.get();

 
 

3. 요소의 검색: findAny()

---

💡 해당 메서드는 스트림 내에서 조건에 “일치하는 요소들 중”에서 “먼저 탐색되는 요소”를 리턴해주는데 사용하는 함수입니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] findAnyArr = {1000, 2000, 3000, 5000};

// 2. Array To OptionalInt
OptionalInt findAnyOptionalInt = Arrays.stream(findAnyArr).findAny();

// 3. OptionalInt to Int
int findAnyArrInt = findAnyOptionalInt.getAsInt();  // 1000

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> findAnyArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Optional<String> : j로 시작하는 단어의 첫번째 요소를 반환합니다.
Optional<String> findAnyOptionalStr = findAnyArrList.stream().filter(i -> i.startsWith("j")).findAny();

// 3. Optional<String> to String
String findAnyArrStr = findAnyOptionalStr.get();

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> findAnyUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Optional<UserDto> : 사용자 아이디가 "a"로 시작한 값에 대한 첫번째 객체를 반환합니다.
Optional<UserDto> findAnyOptionalList = findAnyUserDtoList.stream().filter(item -> item.getUserId().startsWith("a")).findAny();

// 3. Optional<UserDto> to UserDto
UserDto findAnyStr2 = findAnyOptionalList.get();

 

[참고] findFirst vs findAny 차이점.

💡 두개의 메소드들은 조건에 일치하는 요소를 먼저 반환해준다는 공통점을 가지고 있습니다.

메서드	설명	차이점
findFirst()	해당 메서드는 스트림 내에서 조건에 “일치하는 요소들 중”에서 “가장 앞에 있는 요소”를 리턴해주는데 사용되는 함수입니다.	병렬처리 시 가장 앞에 있는 요소를 반환해준다.
findAny()	해당 메서드는 스트림 내에서 조건에 “일치하는 요소들 중”에서 “먼저 탐색되는 요소”를 리턴해주는데 사용하는 함수입니다.	병렬처리 시 가장 먼저 찾는 요소를 반환해준다.

 

💡 [병렬처리] findFirst()의 경우는 병렬 처리를 수행할때 순서를 고려하여서 “가장 앞에 있는 요소”를 반환해줍니다.

List<String> elements = Arrays.asList("a", "a1", "b", "b1", "c", "c1");

Optional<String> firstElement = elements.stream().parallel()
        .filter(s -> s.startsWith("b")).findFirst();

System.out.println("findFirst: " + firstElement.get()); // "b"

 

💡 [병렬처리] findAny()의 경우는 병렬 처리를 수행할때 멀티 쓰레드로 수행하여 “가장 먼저 찾는 요소”를 반환해주기에 차이점이 있습니다.

List<String> elements = Arrays.asList("a", "a1", "b", "b1", "c", "c1");

// 병렬 처리를 수행하기에 순서를 보장하지 않는다.
Optional<String> anyElement = elements.stream().parallel()
        .filter(s -> s.startsWith("b")).findAny();

	System.out.println("findAny: " + anyElement.get()); // "b1"

 

[ 더 알아보기 ]

💡 Stream의 순차 처리와 병렬 처리
- Stream의 경우 처리를 할수 있는 방법이 “순차 처리 스트림”과 “병렬 처리 스트림”이 존재합니다.

💡 순차 처리 스트림
- parallel() 메서드를 이용하지 않은 방식으로 단일 쓰레드내에서 순차적으로 스트림내의 처리를 수행합니다. 해당 처리 방식은 단일 쓰레드로 처리속도는 상대적으로 느리지만 순서를 보장한다는 점이 있습니다.

💡 병렬 처리 스트림
- parallel() 메서드를 사용하여 여러 쓰레드 내에서 작업을 처리를 수행합니다. 이는 병렬로 처리를 하게 되면 여러 쓰레드가 있기에 빠르게 처리를 하지만 순서를 보장하지 않는 점이 있습니다.

 
 

4. 요소의 검사: anyMatch()

---

💡 해당 메서드는 스트림 내의 요소들 중 주어진 조건에 맞는 요소가 “하나 라도 맞는다면” true의 값을 반환해주는데 사용하는 함수입니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] anyMatchArr = {1000, 2000, 3000, 5000};

// 2. Array To OptionalInt : 스트림 요소들 중에 3000 값과 동일한 값이 있는지 여부를 반환
boolean isAnyMatch = Arrays.stream(anyMatchArr).anyMatch(value -> value == 3000);   // [결과값 반환] true

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> anyMatchArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Optional<String> : 스트림 요소들 중에 "park"와 같은 요소가 있는지 여부를 반환
boolean isAnyMatchStr = anyMatchArrList.stream().anyMatch(i -> i.equals("park"));  // [결과값 반환] true

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> anyMatchUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Optional<UserDto> : 스트림 요소들 중에 사용자 아이디가 "ckask123"인 값이 있는지 확인합니다.
boolean isAnyMatchUserDto = anyMatchUserDtoList.stream().anyMatch(item -> item.getUserId().equals("ckask123")); // [결과값 반환] true

 
 
 

5. 요소의 검사: allMatch()

---

💡 해당 메서드는 스트림 내의 요소들 중 “모두 해당 조건에 맞는지”에 대해 판단하여 모두 맞으면 true 값을 반환해주는데 사용하는 함수입니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] allMatchArr = {1000, 2000, 3000, 5000};

// 2. Array To OptionalInt : 스트림 요소들 중에 모든 요소들이 1000보다 큰 값인지 여부를 반환
boolean isAllMatch = Arrays.stream(allMatchArr).allMatch(value -> value > 1000);   // [결과값 반환] true

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> allMatchArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Optional<String> : 스트림 요소들 중에 모든 요소들이 두 글자로 되어 있는지 여부를 반환
boolean isAllMatchStr = allMatchArrList.stream().allMatch(i -> i.length() == 2);  // [결과값 반환] false

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> allMatchUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Optional<UserDto> : 스트림 요소들 중에 모든 사용자 상태가 A 상태인지 여부를 반환
boolean isAllMatchUserDto = allMatchUserDtoList.stream().allMatch(item -> item.getUserSt().equals("A")); // [결과값 반환] false

 
 

6. 요소의 검사: noneMatch()

---

💡 해당 메서드는 스트림 내의 요소들 중 “주어진 조건에 맞는 요소가 없는지”에 대해 판단하여 모두 없다면 true 값을 반환해주는데 사용하는 함수입니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] noneMatchArr = {1000, 2000, 3000, 5000};

// 2. Array To OptionalInt : 스트림 요소들 중에 4000 보다 큰 값이 있는지 여부를 반환
boolean isNoneMatch = Arrays.stream(noneMatchArr).noneMatch(value -> value > 4000);   // [결과값 반환] false

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> noneMatchArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Optional<String> : 스트림 요소들 중에 세 글자로 되어 있는 요소가 있는지 여부를 반환
boolean isNoneMatchStr = noneMatchArrList.stream().noneMatch(i -> i.length() == 3);  // [결과값 반환] true

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> noneMatchUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Optional<UserDto> : 스트림 요소들 중에 사용자 상태가 B 상태인 요소가 있는지 여부를 반환
boolean isNoneMatchUserDto = noneMatchUserDtoList.stream().noneMatch(item -> item.getUserSt().equals("B")); // [결과값 반환] true

 
 

[참고] anyMatch, allMatch, noneMatch 비교

메서드	진위형의 참(true) 값인 경우	진위형의 거짓(false) 값인 경우
anyMatch()	조건 내에 하나라도 맞는다면 true	조건 내의 하나도 맞지 않는 경우 false
allMatch()	조건 내에 모두 맞는다면 true	조건 내의 하나라도 맞지 않는다면 false
noneMatch()	조건에 하나도 맞지 않는다면 false	조건에 하나라도 맞는다면 false

 

7. 요소의 통계 : count()

---

💡 해당 메서드는 스트림 내의 요소들 중 총 요소의 개수를 반환해주는데 사용하는 함수입니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] countArr = {1000, 2000, 3000, 5000};

// 2. Array To IntStream : 스트림 요소들 중에 요소의 갯수를 반환
long countResult = Arrays.stream(countArr).count();   // [결과값 반환] 4

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> countArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Stream<String> : 스트림 요소들 중에 요소의 갯수를 반환
long countResultList = countArrList.stream().count();  // [결과값 반환] 6

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> countUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Stream<UserDto> : 스트림 요소들 중에 요소의 갯수를 반환
long countResultUserDto = countUserDtoList.stream().count(); // [결과값 반환] 3

 
 
 

8. 요소의 통계 : min()

---

 💡 해당 메서드는 스트림 내의 요소들 중 “가장 작은 값”을 반환해주는데 사용하는 함수입니다. 자바 8 스트림 API에서는 min() 메서드를 사용하기 위해서 반환하려는 값이 Comparable 인터페이스를 구현해야 합니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] minArr = {1000, 2000, 3000, 5000};

// 2. Array To OptionalInt : 스트림 요소들 중에 최소값을 반환
int minResult = Arrays.stream(minArr).min().getAsInt();   // [결과값 반환] 1000

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> minArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Stream<String> : 스트림 요소들 중에 알파벳 순서로 가장 앞에 있는 값을 반환
Optional<String> minResultList = minArrList.stream().min((o1, o2) -> o1.compareTo(o2));  // [결과값 반환] jin

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> minUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Stream<UserDto> : 스트림 요소들 중에 사용자 이름 알파벳 순서로 가장 앞에 있는 값을 반환
Optional<UserDto> minResultUserDto = minUserDtoList.stream().min(Comparator.comparing(UserDto::getUserNm)); // [결과값 반환] UserDto{userId='ckask123', userNm='kim', userPw='4321', userSt='A'}

 
 

9. 요소의 통계 : max()

---

💡 해당 메서드는 스트림 내의 요소들 중 “가장 큰 값”을 반환해주는데 사용하는 함수입니다. 자바 8 스트림 API에서는 max() 메서드를 사용하기 위해서 반환하려는 값이 Comparable 인터페이스를 구현해야 합니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] maxArr = {1000, 2000, 3000, 5000};

// 2. Array To OptionalInt : 스트림 요소들 중에 최대값을 반환
int maxResult = Arrays.stream(maxArr).max().getAsInt();   // [결과값 반환] 5000

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> maxArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Stream<String> : 스트림 요소들 중에 알파벳 순서로 가장 뒤에 있는 값을 반환
Optional<String> maxResultList = maxArrList.stream().max((o1, o2) -> o1.compareTo(o2));  // [결과값 반환] park

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> maxUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Stream<UserDto> : 스트림 요소들 중에 사용자 이름 알파벳 순서로 가장 뒤에 있는 값을 반환
Optional<UserDto> maxResultUserDto = maxUserDtoList.stream().max(Comparator.comparing(UserDto::getUserNm)); // [결과값 반환] UserDto{userId='adjh54', userNm='lee', userPw='1234', userSt='S'}

 
 

10. 요소의 연산: sum()

---

 💡 해당 메서드는 스트림 내의 모든 요소들을 더하여 하나의 값으로 반환해주는 함수입니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] sumArr = {1000, 2000, 3000, 5000};

// 2. Array To IntStream : 스트림 요소들 중에 합계를 반환
int sumResult = Arrays.stream(sumArr).sum();   // [결과값 반환] 11000

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> sumArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Stream<String> : 스트림 요소들 중에 문자열 길이의 합계를 반환
int sumResultList = sumArrList.stream().mapToInt(String::length).sum();  // [결과값 반환] 21

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> sumUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Stream<UserDto> : 스트림 요소들 중에 사용자 아이디 길이의 합계를 반환
int sumResultUserDto = sumUserDtoList.stream().mapToInt(user -> user.getUserId().length()).sum(); // [결과값 반환] 22

 
 
 

11. 요소의 연산: average()

---

💡 해당 메서드는 스트림 내의 요소들의 평균 값을 계산해주어 하나의 값으로 반환해주는 함수입니다. average() 메소드를 이용하면 데이터 스트림의 요소들의 평균을 OptionalDouble 형태로 반환합니다. 만약 빈 스트림이라면 OptionalDouble.empty()이 반환됩니다.

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] averageArr = {1000, 2000, 3000, 5000};

// 2. Array To IntStream : 스트림 요소들의 평균을 반환
double averageResult = Arrays.stream(averageArr).average().getAsDouble();   // [결과값 반환] 2750.0

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> averageArrList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. ArrayList to Stream<String> : 스트림 요소들의 길이의 평균을 반환
double averageResultList = averageArrList.stream().mapToInt(String::length).average().getAsDouble();  // [결과값 반환] 3.6666666666666665

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> averageUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. ArrayList to Stream<UserDto> : 스트림 요소들의 비밀번호 길이의 평균을 반환
double averageResultUserDto = averageUserDtoList.stream().mapToInt(item -> item.getUserPw().length()).average().getAsDouble(); // [결과값 반환] 4.0

 
 
 

12. 요소의 수집 : collect()

---

💡 해당 메서드는 스트림 내의 모든 요소들을 수집하여 사용자가 원하는 형태로 변환하는데 사용하는 메소드입니다. 예를 들어 Stream 요소들을 List로 변환하거나 Map으로 변환하는 등 다양한 형태로의 변환이 가능합니다.

/*
 * [CASE1] List 수집하기
 */
// 1. ArrayList Initialize
List<String> userList = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. List 수집하기
List<String> collectList = userList.stream()
        .filter(item -> item.length() > 3)
        .collect(Collectors.toList()); // [결과값 반환] [park, jung]

/*
 * [CASE2] Set 수집하기
 */
// 1. ArrayList Initialize
List<String> userSet = new ArrayList<>(Arrays.asList("kim", "lee", "park", "lee", "jung", "jin"));

// 2. Set 수집하기
Set<String> collectSet = userSet.stream()
        .filter(item -> item.length() > 3)
        .collect(Collectors.toSet()); // [결과값 반환] [park, jung]

/*
 * [CASE3] Map 수집하기
 */
// 1. Object ArrayList Initialize
List<UserDto> userMap = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("A").build(),
        UserDto.userBuilder().userId("angi57").userNm("jung").userPw("4321").userSt("A").build()
);

// 2. Map 수집하기
Map<String, UserDto> collectMap = userMap.stream()
        .filter(item -> item.getUserSt().equals("A"))
        .collect(Collectors.toMap(UserDto::getUserId, Function.identity())); 
// [결과값 반환] {ckask123=UserDto{userId='ckask123', userNm='kim', userPw='4321', userSt='A'}, angi57=UserDto{userId='angi57', userNm='jung', userPw='4321', userSt='A'}}

 
 
 
오늘도 감사합니다. 😀