stream 함수

filter 함수 : 만족하는 데이터만 걸러내는데 사용
map 함수 : 데이터를 변형하는데 사용
sorted 함수 : 데이터가 순서대로 정렬된 stream을 리턴
distinct 함수 : 중복되는 데이터가 제거된 stream을 리턴
flatMap 함수 : Map + Flatten ( Stream<Stream> 을 Stream으로 반환)

 

filter 함수 : 만족하는 데이터만 걸러내는데 사용
• Predicate에 true를 반환하는 데이터만 존재하는 stream을 리턴

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

사용예

public static void main(String[] args) {
    Stream<Integer> numberStream = Stream.of(3, -5, 7, 10, -3);
    Stream<Integer> filteredNumberStream = numberStream.filter(x -> x > 0);
    List<Integer> filteredNumbers = filteredNumberStream.collect(Collectors.toList());
    System.out.println(filteredNumbers);

    List<Integer> newFilteredNumbers = Stream.of(3, -5, 7, 10, -3)
        .filter(x -> x > 0)
        .collect(Collectors.toList());
}

List<User> users = Arrays.asList(user1, user2, user3);
List<User> verifiedUsers = users.stream()
    .filter(User::isVerified)
    .collect(Collectors.toList());
            
List<User> unverifiedUsers = users.stream()
	.filter(user -> !user.isVerified())
	.collect(Collectors.toList());
    
List<Order> orders = Arrays.asList(order1, order2, order3, order4, order5);
List<Order> filteredOrder = orders.stream()
        .filter(order -> order.getStatus() == OrderStatus.ERROR)
        .collect(Collectors.toList());

 

map 함수 : 데이터를 변형하는데 사용
• 데이터에 해당 함수가 적용된 결과물을 제공하는 stream을 리턴

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

사용예

 

public static void main(String[] args) {
    List<Integer> numberList = Arrays.asList(3, 6, -4);
    List<Integer> numberListX2 = numberList.stream()
            .map(x -> x * 2)
            .collect(Collectors.toList());
    System.out.println(numberListX2);

    Stream<Integer> numberListStream = numberList.stream();
    Stream<String> strStream = numberListStream.map(x -> "Number is " + x);
    List<String> strList = strStream.collect(Collectors.toList());
    System.out.println(strList);
}

List<User> users = Arrays.asList(user1, user2, user3);
List<String> emailAddresses = users.stream()
        .map(User::getEmailAddress)
        .collect(Collectors.toList());

List<Long> ordersInErrorsIn24hrs = orders.stream()
        .filter(order -> (order.getStatus() == OrderStatus.ERROR))
        .filter(order -> order.getCreatedAt().isAfter(now.minusHours(24)))
        .map(Order::getCreatedByUserId)
        .collect(Collectors.toList());

 

sorted 함수 : 데이터가 순서대로 정렬된 stream을 리턴
• 데이터의 종류에 따라 Comparator가 필요할 수 있음

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);

사용예

List<User> users = Arrays.asList(user1, user2, user3);
List<User> sortedUsers = users.stream()
        .sorted((u1, u2) -> u1.getName().compareTo(u2.getName()))
        .collect(Collectors.toList());

List<Order> orderListCreatedAtBy = orders.stream()
        .sorted((o1, o2) -> o1.getCreatedAt().compareTo(o2.getCreatedAt()))
        .collect(Collectors.toList());

 

distinct 함수 : 중복되는 데이터가 제거된 stream을 리턴

Stream<T> distinct();

사용예

List<Integer> numbers = Arrays.asList(3, -5, 4, -5, 2, 3);
List<Integer> distinctNumbers = numbers.stream()
        .distinct()
        .collect(Collectors.toList());
List<Long> uniqSortedCreatedByUserId = orders.stream()
        .map(Order::getCreatedByUserId)
        .distinct()
        .sorted()
        .collect(Collectors.toList());

 

flatMap 함수 : Map + Flatten
• 데이터에 함수를 적용한 후 중첩된 stream을 연결하여 하나의 stream으로 리턴

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

사용예

String[][] cities = new String[][] {
    { "Seoul", "Busan" },
    { "San Francisco", "New York" },
    { "Madrid", "Barcelona" }
};
Stream<String[]> cityStream = Arrays.stream(cities);
Stream<Stream<String>> cityStreamStream = cityStream.map(x -> Arrays.stream(x));
List<Stream<String>> cityStreamList = cityStreamStream.collect(Collectors.toList());
System.out.println(cityStreamList);

Stream<String[]> cityStream2 = Arrays.stream(cities);
Stream<String> flattenedCityStream = cityStream2.flatMap(Arrays::stream);
List<String> flattenedCityList = flattenedCityStream.collect(Collectors.toList());
System.out.println(flattenedCityList);

List<Order> orders = Arrays.asList(order1, order2, order3);
List<OrderLine> mergedOrderLines = orders.stream() 		// Stream<Order>
        .map(Order::getOrderLines)					// Stream<List<OrderLine>>
        .flatMap(List::stream) 						// Stream<OrderLine>
        .collect(Collectors.toList());