Formoat's Open Blog
스트림 중간 처리 본문
Function | Method | Interface | Remarks |
필터링 | disinct() | Stream, IntStream, LongStream, DoubleStream | 중복을 제거한 요소로 구성된 스트림 반환 |
filter( ... ) | Predicate 조건에 맞는 요소로 구성된 스트림 반환 | ||
매핑 | flatMap( ... ) | Stream, IntStream, LongStream, DoubleStream | 한 개의 요소를 대체하는 복수개의 요소들로 구성된 스트림 반환 |
flatMapToDouble( ... ) | Stream | ||
flatMapToInt( ... ) | |||
flatMapToLong( ... ) | |||
map( ... ) | Stream, IntStream, LongStream, DoubleStream | Function을 이용해 매핑한 요소로 구성된 스트림 반환 | |
mapToDouble( ... ) | Stream, IntStream, LongStream | ||
mapToInt( ... ) | Stream, LongStream, DoubleStream | ||
mapToLong( ... ) | Stream, IntStream, DoubleStream | ||
mapToObj( ... ) | IntStream, LongStream, DoubleStream | ||
asDoubleStream() | IntStream, LongStream | 다른 타입 요소를 double타입 요소로 대체 | |
asLongStream() | IntStream, DoubleStream | 다른 타입 요소를 long타입 요소로 대체 | |
boxed() | IntStream, LongStream, DoubleStream | 기본 타입 요소를 Wrapper타입으로 박싱 | |
정렬 | sorted( ... ) | Stream, IntStream, LongStream, DoubleStream | Comparable/Comparator를 이용해 정렬 |
루핑 | peek( ... ) | forEach와 흡사하나 중간 처리 메소드 |
<표> 중간 처리 메소드의 종류
# 필터링
중간 처리 기능으로 요소를 걸러내는 역할을 한다.
(1) distinct() : Object 클래스의 equals() 메소드를 통해 true값이 나오면 동일한 객체로 판단해 중복을 제거
(2) filter() : 매개값으로 주어진 함수적 인터페이스인 Predicate가 true를 반환하는 요소만 필터링
FilterExample.java
public class FilterExample {
public static void main(String[] args) {
List<String> list = Arrays.asList("김태호", "박철민", "이호진", "김태호", "김태영", "최웅진", "김호박", "박창진");
list.stream() // 오리지날 스트림 생성
.distinct() // 요소중 중복 제거
.filter(s -> s.startsWith("김")) // 성이 김씨인 요소만 필터링
.forEach(System.out::println); // 최종 처리된 스트림 출력
}
}
// 실행결과 //
----------------------------------------------------
김태호
김태영
김호박
# 매핑
중간 처리 기능으로 스트림의 요소를 다른 요소로 대체하는 것을 말한다.
예를 들자면 객체 요소를 int, long등 으로 대체하거나, 객체 요소를 또 다른 객체 요소로 대체할 수 있다.
매핑은 반드시 1:1로 매핑되는 것은 아니며 하나의 요소를 복수의 요소로 대체할 수 있다.
(1) flatXXX() : 한 개의 요소를 대체하는 복수개의 요소들로 구성된 스트림 생성
(2) mapXXX() : 요소를 다른타입으로 대체한 요소로 구성된 스트림 생성
(3) asXXXStream() : 각각 다른 타입의 요소를 double 또는 long타입의 요소로 대체해 스트림 생성
(4) boxed() : 기본타입의 요소를 객체타입인 Wrapper 타입으로 박싱해 스트림 생성 (Integer, Double, Long)
FlatMapExample.java
public class FlatMapExample {
public static void main(String[] args) {
List<String> list = Arrays.asList("king in", "the north");
list.stream()
.flatMap(str->Arrays.stream(str.split(" "))) // 문자열을 구분자를 통해 복수로 나누어 새로운 스트림으로 구성
.forEach(System.out::println); // 최종 처리된 스트림 출력
System.out.println("========");
List<String> list2 = Arrays.asList("1, 2", "5, 6");
list2.stream()
.flatMapToInt(a -> {
String[] arr = a.split(","); // 문자열을 구분자를 통해 복수로 나눔
int[] arrInt = new int[arr.length];
for (int i=0; i<arr.length; i++) {
arrInt[i] = Integer.parseInt(arr[i].trim()); // 문자열을 정수로 변환
}
return Arrays.stream(arrInt); // 변환된 정수배열을 스트림으로 구성
})
.forEach(s -> System.out.print(s+" ")); // 최종 처리된 스트림 출력
}
}
// 실행결과 //
----------------------------------------------------
king
in
the
north
========
1 2 5 6
MapExample.java
public class MapExample {
public static void main(String[] args) {
List<Member> memberList = Arrays.asList(
new Member("김태호", 28),
new Member("홍길동", 40),
new Member("김삿갓", 58)
);
memberList.stream()
.mapToInt(Member::getAge) // Member객체요소를 int타입 요소로 대체
.forEach(System.out::println); // 최종 처리된 스트림 출력
}
}
// 실행결과 //
----------------------------------------------------
28
40
58
# 정렬
중간 처리 기능으로 최종 처리되기전 요소들을 정렬해야 할 때 사용한다.
Return Type | Method | Remarks |
Stream<T> | sorted() | 객체를 객체내의 Comparable 구현 방법에 따라 정렬 |
Stream<T> | sorted(Comparator<T>) | 객체를 주어진 Comparator 구현 방법에 따라 정렬 |
DoubleStream | sorted() | double 요소를 올림차순으로 정렬 |
IntStream | sorted() | int 요소를 올림차순으로 정렬 |
LongStream | sorted() | long 요소를 올림차순으로 정렬 |
<표> 정렬기능의 메소드 종류
(1) 객체 요소일 경우 Comparable 을 구현하지 않은채 첫번째 sorted() 메소드를 호출할 경우 ClassCastException이 발생
(2) 객체 요소가 Comparable을 구현하지 않았거나, 구현했더라도 다른 비교방법으로 정렬을 하고 싶다면 두번째 sorted() 메소드 사용
// a와 b를 비교해 a가 작다면 음수, a가 크다면 양수, 같다면 0을 반환 (올림차순)
sorted((a, b) -> {
if (a < b) return -1;
else if (a > b) return 1;
else return 0;
});
< Comparator는 함수적 인터페이스로 람다식을 이용해 표현할 수 있다. >
// 객체 요소가 Comparable을 구현하고 있을 경우 기본 비교 방법 (오름차순)
sorted();
sorted( (a, b) -> a.compareTo(b) );
sorted( Comparator.naturalOrder() );
// 객체 요소가 Comparable을 구현하고 있을 경우 기본 비교 방법의 반대 방법 (내림차순)
sorted( (a, b) -> b.compareTo(a) );
sorted( (a, b) -> Comparator.reverseOrder() );
< 정렬 코드의 예 >
# 루핑
중간 처리와 최종 처리에 모두 포함되는 기능으로 요소 전체를 반복하는 것을 말한다.
(1) peek(Consumer<T> ... )
최종 처리 기능 중 forEach와 같은 기능으로 스트림의 요소를 하나씩 가져와 소비하는
Consumer 를 매개값으로 가지고 있다. 다만 forEach와 다른 점은 중간 처리 기능이라는 점이다. 때문에 최종 처리의
집계 기능이 시작되어야만 집계를 시작 한다.
PeekExample.java
public class PeekExample {
public static void main(String[] args) {
List<String> list = Arrays.asList("김태호", "김미영", "김병준", "이하늘", "이영애");
long count = list.stream()
.filter(s->s.startsWith("김"))
.peek(System.out::println) // 최종 처리 메소드인 count메소드가 실행한 뒤부터 콘솔에 출력
.count(); // 만약 최종 처리 메소드가 실행되지 않는다면 중간 처리 과정은 시작되지 않는다.
System.out.println(count);
}
}
// 실행결과 //
----------------------------------------------------
김태호
김미영
김병준
3
'Java > Java Basic' 카테고리의 다른 글
제네릭 (Generic) (0) | 2019.09.04 |
---|---|
스트림 최종 처리 (0) | 2019.09.04 |
스트림 (Stream) (0) | 2019.09.04 |
컬렉션 - Stack, Queue (0) | 2019.09.04 |
컬렉션 - Tree (0) | 2019.09.04 |