[Java] 중간 연산 - 필터링(Filtering)과 맵핑(Mapping)

필터링(Filtering)

📌 필터링(Filtering)

: 스트림을 구성하는 데이터 중 일부를 조건에 따라 걸러내는 행위.

  매개변수형 : Predicate

  → boolean test(T t) 추상 메소드 구현한 람다식을 인자로  전달해야 함. 

Stream<T> filter(Predicate<? super T> predicate)

 

📄 StreamFilteringTest.java

package stream;

import java.util.Arrays;
import java.util.List;

public class StreamFilteringTest {

	public static void main(String[] args) {
		int[] ar = { 1, 2, 3, 4, 5 };
		
		Arrays.stream(ar)  // 배열 기반 스트림. 
		      .filter(n -> n%2 == 1)  // 홀수만 통과.
		      .forEach(n -> System.out.print(n + " "));  // 1 3 5 
		System.out.println();
		
		List<String> li = Arrays.asList("apple", "banana", "watermelon", "cherry", "pear");
		
		li.stream()  // 컬렉션 인스턴스 기반 스트림.
		  .filter(s -> s.length() > 5)  // 문자열 길이 5보다 크면 통과.
		  .forEach(s -> System.out.print(s + " "));  // banana watermelon cherry 
		System.out.println();
	}

}

 

맵핑(Mapping)

📌 맵핑을 하면 스트림의 데이터 형이 달라짐.

 

📌 맵핑(Mapping)에 사용되는 대표적인 메소드

  : 매개변수형 : Function

    → R apply(T t) 추상 메소드 구현한 람다식을 인자로  전달해야 함. 

   

   데이터마다 apply 메소드를 호출한 후, 결과 값을 모아 새로운 스트림을 생성함. 

<R> Stream<T> map(Function<? super T, ? extends R> mapper)
<R> Stream<R> map(Function<T, R> mapper)

IntStream mapToInt(ToIntFunction<T> mapper)
DoubleStream mapToDouble(ToDoubleFunction<T> mapper)
LongStream mapToLong(ToLongFunction<T> mapper)

 

📄 StreamMappingTest.java

package stream;

import java.util.Arrays;
import java.util.List;

public class StreamMappingTest {

	public static void main(String[] args) {
		List<String> li = Arrays.asList("apple", "banana", "cherry", "watermelon", "pear");
		
		li.stream()
		  .map(s -> s.length())  // 문자열 길이로 맵핑. 
		  .forEach(n -> System.out.print(n + " "));  // 5 6 6 10 4 
		System.out.println();
	}

}

 

📌 기본 자료형의 값을 반환하는 경우, 맵핑 메소드

IntStream mapToInt(ToIntFunction<? super T> mapper)
IntStream mapToInt(ToIntFunction<T> mapper)

LongStream mapToLong(ToLongFunction<? super T> mapper)
LongStream mpaToLong(ToLongFunction<T> mapper)

DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)
DoubleStream mapToDouble(ToDoubleFunction<T> mapper)

 

📄 StreamMappingTest2.java

package stream;

import java.util.Arrays;
import java.util.List;

public class StreamMappingTest2 {

	public static void main(String[] args) {
		List<String> li = Arrays.asList("apple", "banana", "cherry", "watermelon", "pear");
		
		li.stream()
		  .mapToInt(s -> s.length())
		  .forEach(n -> System.out.print(n + " "));  // 5 6 6 10 4 
		System.out.println();
	}

}

 

중간 연산 두 번 하는 경우

📄 StreamFilteringMappingTest.java

package stream;

import java.util.ArrayList;
import java.util.List;

class FruitPriceInfo {
	private String name;
	private int price;
	
	public FruitPriceInfo(String name, int price) {
		this.name = name;
		this.price = price;
	}
	
	public int getPrice() {
		return price;
	}
	
	public String getName() {
		return name;
	}
}
public class StreamFilteringMappingTest {

	public static void main(String[] args) {
		List<FruitPriceInfo> li = new ArrayList<>();
		
		li.add(new FruitPriceInfo("apple", 3000));
		li.add(new FruitPriceInfo("pear", 2000));
		li.add(new FruitPriceInfo("watermelon", 10000));
		li.add(new FruitPriceInfo("cherry", 5000));
		
		li.stream()
		  .filter(n -> n.getName().length() > 5)  // 문자열 길이 5보다 크면, 통과.
		  .map(n -> n.getName())  
		  .forEach(s -> System.out.print(s + " "));  // watermelon cherry 
	}

}

 

맵핑(Mapping) - flatMap

📌 Stream<T>의 flatMap 시리즈의 메소드

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
<R> Stream<R> flatMap(Function<T, Stream<R>> mapper)

IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper)
IntStream flatMapToInt(Function<T, IntStream> mapper)

DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper)
DoubleStream flatMapToDouble(Function<T, DoubleStream> mapper)

LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper)
LongStream flatMapToLong(Function<T, LongStream> mapper)

 

📌 flatMap에 전달할 람다식에서는 스트림을 생성하고 이를 반환해야 함. 

 

📄 FlatMapTest.java

package stream2;

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

class Student {
	private int kor;
	private int eng;
	private int math;
	
	public Student(int kor, int eng, int math) {
		this.kor = kor;
		this.eng = eng;
		this.math = math;
	}
	
	public int getKor() { return kor; }
	public int getEng() { return eng; }
	public int getMath() { return math; }
}

public class FlatMapTest {

	public static void main(String[] args) {
		Student[] s = { 
				new Student(100, 98, 90),
				new Student(30, 49, 83),
				new Student(95, 83, 42)
		};
		
		Stream<Student> ss = Arrays.stream(s);
		
		IntStream si = ss.flatMapToInt(i -> IntStream.of(i.getKor(), i.getEng(), i.getMath()));
		
		double avg = si.average().getAsDouble();
		System.out.println(avg);  // 74.44444444444444a
		
	}

}

+ 추가 설명

- OptionalDouble average( )

  : 인터페이스 IntStream, LongStream, DoubleStream에 존재하는 메소드.