스트림 요소 처리

요소 걸러내기(필터링)

• 오리지널 스트림 요소 중 최종 처리 대상에 해당되는 요소만 추출하기 위한 중간 처리 기능

 

필터링 메소드

메소드		설명
Stream IntStream LongStream DoubleStream	distinct()	중복 제거
	filter(Predicate<T>)	조건 필터링 매개변수의 타입은 요소 타입에 따른 함수형 인터페이스이므로 람다식 작성 가능
	filter(IntPredicate)
	filter(LongPredicate)
	filter(DoublePredicate)

 

• fliter() 메소드는 false 인 요소를 제외하고, true인 요소로만 이루어진 스트림을 새로 생성한다.

 

Predicate(함수형 인터페이스)의 추상 메소드

인터페이스	추상 메소드	설명
Predicate<T>	boolean test(T t)	객체 T를 조사
IntPredicate	boolean test(int value)	int 값을 조사
LongPredicate	boolean test(long value)	long 값을 조사
DoublePredicate	boolean test(double value)	double 값을 조사

 

• 모든 Predicate는 매개값을 조사하여 boolean을 리턴하는 test() 메소드를 가지고 있다.

 

T -> { ... return true }
T -> true;    //return 문만 있을 경우 중괄호와 return 키워드 생략 

 

//List 컬렉션 생성
List<String> list = new ArrayList();
list.add("홍길동");
list.add("이길동");
list.add("김길동");
list.add("신길동");
list.add("신사동");
list.add("김길동");
list.add("신길동");
 
//중복 요소 제거
System.out.print("중복 제거 : ");
list.stream()
    .distinct()
    .forEach(n -> System.out.print(n + ", "));
System.out.println("\n");
 
//'신'으로 시작하는 요소만 필터링
System.out.print("필터링 : ");
list.stream()
    .filter(n -> n.startsWith("신"))    //String 클래스의 startWith() 메소드 : 주어진 문자열로 시작하며 true, 아니면 false를 리턴.
    .forEach(n -> System.out.print(n + ", "));
System.out.println("\n");
 
//중복 요소를 먼저 제거하고,  신으로 시작하느 요소만 필터링
System.out.print("중복 제거 + 필터링 : ");
list.stream()
    .distinct()
    .filter(n -> n.startsWith("신"))
    .forEach(n -> System.out.print(n + ", "));

 

---

요소 변환(매핑)

• 매핑(mapping) : 스트림의 기존 요소를 다른 요소로 변환하는 중간 처리 기능
  - 타입 변환과 유사하다.

 

---

요소를 다른 요소로 변환

• "map"으로 시작하는 매핑 메소드는 매개값으로 받은 요소를 다른 요소로 변환하여 새로운 스트림을 생성한다.

 

주요 매핑 메소드

리턴 타입	메소드	변환 과정
Stream<R>	map(Function<T, R>	T → R
IntStream	mapToInt(ToIntFunction<T>)	T → int
LongStream	mapToLong(ToLongFunction<T>)	T → long
DoubleStream	mapToDouble(ToDoubleFunction<T>)	T → double
Stream<U>	mapToObj(IntFunction<U>)	int → U
LongStream	mapToLong(IntToLongFunction)	int → long
DoubleStream	mapToDouble(IntToDobuleFunction)	int → double
Stream<U>	mapToObj(LongFunction<U>)	long → U
IntStream	mapToInt(LongToIntFunction)	long → int
DoubleStream	mapToDouble(LongToDoubleFunction)	long → double
Stream<U>	mapToObj(DoubleFunction<U>)	double → U
IntStream	mapToInt(DoubleToIntFunction)	double → int
LongStream	mapToLong(DoubleToLongFunction)	double → long

 

 

Function 항수형 인터페이스의 추상 메소드

인터페이스	추상 메소드	매개 값 → 리턴 값
Function<T,R>	R apply(T t)	T → R
IntFunction<R>	R apply(int value)	int → R
LongFunction<R>	R apply(long value)	long → R
DoubleFunction<R>	R apply(double value)	double → R
ToIntFunction<T>	int applyAsInt(T value)	T → int
ToLongFunction<T>	long applyAsLong(T value)	T → long
ToDoubleFunction<T>	double applyAsDouble(T value)	T → double
IntToLongFunction	long applyAsLong(int value)	int → long
IntToDoubleFunction	double applyAsDouble(int value)	int → double
LongToIntFunction	int applyAsInt(long value)	long → int
LongToDoubleFunction	double applyAsDouble(long value)	long → double
DoubleToIntFunction	int applyAsInt(double value)	double → int
DoubleToLongFunction	long applyAsLong(double value)	double → long

 

T -> { ... return R; }
T -> R;    //return 문만 있을 경우 중괄호와 return 키워드 생략 가능

 

public class Student {
    private String name;
    private int score;
    
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    
    public String getName() { return name; }
    public int getScore() { return score; }
}

 

//List 컬렉션 생성
List<Student> studentList = new ArrayList<>();
studentList.add(new Student("홍길동", 85));
studentList.add(new Student("홍길동", 92));
studentList.add(new Student("홍길동", 87));
 
//Student를 score 스트림으로 변환
studentList.stream()
    .mapToInt(s -> s.getScore())
    .forEach(s -> System.out.println(s));

 

기본 타입 변환 관련 메소드

리턴 타입	메소드	변환 과정
LongStream	asLongStream()	int → long
DoubleStream	asDoubleStream()	int → dobule
		long → double
Stream<Integer>	boxed()	int → Integer
Stream<Long>		long → Long
Stream<Double>		double → Double

 

---

요소를 복수 개의 요소로 변환

• 하나의 요소를 여러 개의 요소들로 변환하여 새로운 스트림 생성
• flatMap() 메소드 사용

 

flatMap() 메소드

리턴 타입	메소드	변환 과정
Stream<R>	flatMap(Function<T, Stream<R>>)	T → Stream<R>
DoubleStream	flatMap(DoubleFunction<DoubleStream>)	double → DoubleStream
IntStream	flatMap(IntFunction<IntStream>)	int → IntStream
LongStream	flatMap(LongFunction<LongStream>)	long → LongStream
DoubleStream	flatMapToDouble(Function<T, DoubleStream>)	T → DoubleStream
IntStream	flatMapToInt(Function<T, IntStream>)	T → IntStream
LongStream	flatMapToLong(Function<T, LongStream>)	T → LongStream

 

//문장 스트림을 단어 스트림으로 변환
List<String> list1 = new ArrayList();
list1.add("this is java");
list1.add("i am a best developer");
list1.stream()
    .flatMap(data -> Arrays.stream(data.split(" " )))
    .forEach(word -> System.out.println(word));
 
System.out.println();
 
//문자열 숫자 목록 스트림을 숫자 스트림으로 변환
List<String> list2 = Arrays.asList("10, 20, 30", "40, 50");    //수정할 수 없는 리스트 생성
list2.stream()
    .flatMapToInt(data -> {
        
        //String 배열을 int 배열로 변환
        String[] strArr = data.split(",");
        int[] intArr = new int[strArr.length];
        for (int i = 0; i <strArr.length; i++) {
            intArr[i] = Integer.parseInt(strArr[i].trim());
        }
        
        //int 배열을 IntStream으로 변환
        return Arrays.stream(intArr);
    })
    .forEach(number -> System.out.println(number));;

 

 

---

요소 정렬

• 기존 요소를 오름차순이나 내림차순으로 정렬하는 중간 처리 기능
  - 요소의 순서만 변경
• 기존 요소가 Comparable을 구현했다면 매개값 없이 정렬이 가능하다.
  - 기존 요소가 Comparable을 구현하지 않는 경우 비교자(Comparator)를 제공해줘야 한다.

 

리턴 타입	메소드	설명
Stream<T>	sorted()	Comparable 요소를 정렬하여 새로운 스트림 생성
Stream<T>	sorted(Comparator<T>)	요소를 COmparator에 따라 정렬하여 새로운 스트림 생성