스트림 중간 처리

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