티스토리 뷰

Backend/Java8

#24 Advanced Stream - Max / Min / Count

RadderNepa 2022. 10. 13. 00:23

출처 - The Red: 25개 백엔드 개발 필수 현업 예제를 통해 마스터하는 JAVA STREAM(fastcampus)
출처 - The Red: 25개 백엔드 개발 필수 현업 예제를 통해 마스터하는 JAVA STREAM(fastcampus)

 

 

● 도입

- 종결 처리에 대해서 배워볼 것이다.

- 종결 처리 : 최종적으로 Stream 안에 있는 데이터들을 모아 반환해주는 역할

- 위 사진 속 중간 처리들은 바로 바로 실행되는 것이 아니라 종결 처리가 필요할 때 비로소 실행된다.

List<Stream<String>> cityStreamList = cityStreamStream.collect(Collectors.toList());

- 이전 글에서까지 유일하게 배운 종결 처리가 위의 코드이다.  -->  Collectors.toList()
- Stream을 List 형태로 모아주는 종결 처리

 

 

● Max / Min / Count - Stream 안의 데이터의 최대값 / 최소값 / 개수

Optional<T> max(Comparator<? super T> comparator);
Optional<T> min(Comparator<? super T> comparator);
long count();

max
– Stream 안의 데이터 중 최대값을 반환, Stream이 비어있다면 빈 Optional 반환
- 따라서 max method의 반환 타입은 Optional이다.
- 데이터를 서로 어떻게 비교해야 하는지를 알려줄 Comparator를 받아야한다.

min
– Stream 안의 데이터 중 최소값을 반환, Stream이 비어있다면 빈 Optional 반환
- 따라서 min method의 반환 타입은 Optional이다.
- 데이터를 서로 어떻게 비교해야 하는지를 알려줄 Comparator를 받아야한다.

count
– Stream 안의 데이터의 개수를 반환
- 반환 타입은 Long 이다.

 

 

● 실습

package com.fastcampus.functionalprogramming.chapter8.model;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

public class User {
	private int id;
	private String name;
	private String emailAddress;
	private boolean isVerified;
	private LocalDateTime createdAt;
	private List<Integer> friendUserIds;
	
	public int getId() {
		return id;
	}
	
	public User setId(int id) {
		this.id = id;
		return this;
	}
	
	public String getName() {
		return name;
	}
	
	public User setName(String name) {
		this.name = name;
		return this;
	}
	
	public Optional<String> getEmailAddress() {
		return Optional.ofNullable(emailAddress);
	}
	
	public User setEmailAddress(String emailAddress) {
		this.emailAddress = emailAddress;
		return this;
	}
	
	public boolean isVerified() {
		return isVerified;
	}
	
	public User setVerified(boolean isVerified) {
		this.isVerified = isVerified;
		return this;
	}
	
	public LocalDateTime getCreatedAt() {
		return createdAt;
	}
	
	public User setCreatedAt(LocalDateTime createdAt) {
		this.createdAt = createdAt;
		return this;
	}
	
	public List<Integer> getFriendUserIds() {
		return friendUserIds;
	}
	
	public User setFriendUserIds(List<Integer> friendUserIds) {
		this.friendUserIds = friendUserIds;
		return this;
	}
	
	@Override
	public String toString() {
		return "User [id=" + id + ", " + (name != null ? "name=" + name + ", " : "")
				+ (emailAddress != null ? "emailAddress=" + emailAddress + ", " : "") + "isVerified=" + isVerified
				+ ", " + (friendUserIds != null ? "friendUserIds=" + friendUserIds : "") + "]";
	}
}

 

1. max

package com.fastcampus.functionalprogramming.chapter8;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

import com.fastcampus.functionalprogramming.chapter8.model.Order;
import com.fastcampus.functionalprogramming.chapter8.model.Order.OrderStatus;
import com.fastcampus.functionalprogramming.chapter8.model.User;

public class Chapter8Section1 {
	public static void main(String[] args) {
		// 1. max
		Optional<Integer> max = Stream.of(5 ,3, 6, 2, 1).max((x, y) -> x - y);
		Optional<Integer> max2 = Stream.of(5 ,3, 6, 2, 1).max(Integer::compareTo);
		System.out.println(max.get());
		System.out.println(max2.get());
	}
}

 

2. min

package com.fastcampus.functionalprogramming.chapter8;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

import com.fastcampus.functionalprogramming.chapter8.model.Order;
import com.fastcampus.functionalprogramming.chapter8.model.Order.OrderStatus;
import com.fastcampus.functionalprogramming.chapter8.model.User;

public class Chapter8Section1 {
	public static void main(String[] args) {
		// 2. min
		User user1 = new User()
				.setId(101)
				.setName("Alice")
				.setVerified(true)
				.setEmailAddress("alice@fastcampus.co.kr");
		User user2 = new User()
				.setId(102)
				.setName("Bob")
				.setVerified(false)
				.setEmailAddress("bob@fastcampus.co.kr");
		User user3 = new User()
				.setId(103)
				.setName("Charlie")
				.setVerified(false)
				.setEmailAddress("charlie@fastcampus.co.kr");
	    User user4 = new User()
	    		.setId(104)
	    		.setName("David")
	    		.setVerified(true)
	    		.setEmailAddress("david@fastcampus.co.kr");
		
		List<User> users = Arrays.asList(user1, user2, user3);
		
		// 이름순으로 정렬했을 때 맨 앞에 오는 user 이름 찾기(가나다순)
		Optional<String> minName = users.stream().map(User::getName).min((u1, u2) -> u1.compareTo(u2));
		System.out.println(minName.get());
		
		// 이름순으로 정렬했을 때 맨 앞에 오는 user 찾기(가나다순)
		Optional<User> firstUser = users.stream().min((u1, u2) -> u1.getName().compareTo(u2.getName()));
		System.out.println(firstUser.get());
	}
}

 

3. count

package com.fastcampus.functionalprogramming.chapter8;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

import com.fastcampus.functionalprogramming.chapter8.model.Order;
import com.fastcampus.functionalprogramming.chapter8.model.Order.OrderStatus;
import com.fastcampus.functionalprogramming.chapter8.model.User;

public class Chapter8Section1 {
	public static void main(String[] args) {
		// 2. min
		User user1 = new User()
				.setId(101)
				.setName("Alice")
				.setVerified(true)
				.setEmailAddress("alice@fastcampus.co.kr");
		User user2 = new User()
				.setId(102)
				.setName("Bob")
				.setVerified(false)
				.setEmailAddress("bob@fastcampus.co.kr");
		User user3 = new User()
				.setId(103)
				.setName("Charlie")
				.setVerified(false)
				.setEmailAddress("charlie@fastcampus.co.kr");
	    User user4 = new User()
	    		.setId(104)
	    		.setName("David")
	    		.setVerified(true)
	    		.setEmailAddress("david@fastcampus.co.kr");
		
		// 3. count
		// 양수의 개수
		Long positiveIntegerCount = Stream.of(1, -4, 5, -3, 6).filter(x -> x > 0).count();
		System.out.println("양수의 개수 : " + positiveIntegerCount);
		
		// 최근 24시간 이내 가입한 user 중 아직 검증이 되지 않은 user의 수
		LocalDateTime now = LocalDateTime.now(ZoneId.of("Asia/Seoul"));
	    user1.setCreatedAt(now.minusDays(2));	// 현재 기준 2일 전에 가입
	    user2.setCreatedAt(now.minusHours(10));	// 현재 기준 10시간 전에 가입
	    user3.setCreatedAt(now.minusHours(1));	// 현재 기준 1시간 전에 가입
	    user4.setCreatedAt(now.minusHours(27));	// 현재 기준 27시간 전에 가입
	    
	    List<User> users2 = Arrays.asList(user1, user2, user3, user4);
	    /*
	     * 총 3단계
	     * 1. 최근 24시간 이내 가입한 user 중
	     * 2. 아직 검증이 되지 않은
	     * 3. user의 수
	     */
	    Long unverfiedUsersIn24Hrs = users2.stream()
	    			.filter(user -> user.getCreatedAt().isAfter(now.minusDays(1)))
	    			.filter(user -> !(user.isVerified()))
	    			.count();
	    System.out.println("user 수 : " + unverfiedUsersIn24Hrs);
	}
}

 

4. 숙제

package com.fastcampus.functionalprogramming.chapter8.model;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;

public class Order {
	private long id;
	private LocalDateTime createdAt;
	private long createdByUserId;
	private OrderStatus status;
	private BigDecimal amount;
	private List<OrderLine> orderLines;

	public enum OrderStatus {
		CREATED,
		IN_PROGRESS,
		ERROR,
		PROCESSED
	}

	public long getId() {
		return id;
	}

	public Order setId(long id) {
		this.id = id;
		return this;
	}

	public LocalDateTime getCreatedAt() {
		return createdAt;
	}

	public Order setCreatedAt(LocalDateTime createdAt) {
		this.createdAt = createdAt;
		return this;
	}

	public long getCreatedByUserId() {
		return createdByUserId;
	}

	public Order setCreatedByUserId(long createdByUserId) {
		this.createdByUserId = createdByUserId;
		return this;
	}

	public OrderStatus getStatus() {
		return status;
	}

	public Order setStatus(OrderStatus status) {
		this.status = status;
		return this;
	}

	public BigDecimal getAmount() {
		return amount;
	}

	public Order setAmount(BigDecimal amount) {
		this.amount = amount;
		return this;
	}

	public List<OrderLine> getOrderLines() {
		return orderLines;
	}

	public Order setOrderLines(List<OrderLine> orderLines) {
		this.orderLines = orderLines;
		return this;
	}

	@Override
	public String toString() {
		return "Order [id=" + id + ", " + (createdAt != null ? "createdAt=" + createdAt + ", " : "")
				+ "createdByUserId=" + createdByUserId + ", " + (status != null ? "status=" + status + ", " : "")
				+ (amount != null ? "amount=" + amount + ", " : "")
				+ (orderLines != null ? "orderLines=" + orderLines : "") + "]";
	}
}
package com.fastcampus.functionalprogramming.chapter8;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

import com.fastcampus.functionalprogramming.chapter8.model.Order;
import com.fastcampus.functionalprogramming.chapter8.model.Order.OrderStatus;
import com.fastcampus.functionalprogramming.chapter8.model.User;

public class Chapter8Section1 {
	public static void main(String[] args) {
	    // 숙제
    	Order order1 = new Order()
			.setId(1001L)
			.setAmount(BigDecimal.valueOf(2000))
			.setStatus(OrderStatus.CREATED);
    	Order order2 = new Order()
			.setId(1002L)
			.setAmount(BigDecimal.valueOf(4000))
			.setStatus(OrderStatus.ERROR);
    	Order order3 = new Order()
			.setId(1003L)
			.setAmount(BigDecimal.valueOf(3000))
			.setStatus(OrderStatus.ERROR);
    	Order order4 = new Order()
			.setId(1004L)
			.setAmount(BigDecimal.valueOf(7000))
			.setStatus(OrderStatus.PROCESSED);
    	
        List<Order> orders = Arrays.asList(order1, order2, order3, order4);
        
        // ERROR 상태인 order들 중에서 Amount가 가장 큰 order 찾아내기
	    /*
	     * 총 3단계
	     * 1. ERROR 상태인 order들 중에서
	     * 2. Amount가 가장 큰
	     * 3. order 찾아내기
	     */
        Optional<Order> errorMaxAmountUser = orders.stream()
        					.filter(order -> order.getStatus() == OrderStatus.ERROR)
        					.max((o1, o2) -> o1.getAmount().compareTo(o2.getAmount()));
        
        System.out.println(errorMaxAmountUser.get());

        // ERROR 상태인 order들 중에서 Amount가 가장 큰 order의 금액 출력
        BigDecimal errorMaxAmount = orders.stream()
        								.filter(order -> order.getStatus() == OrderStatus.ERROR)
        								.map(Order::getAmount)
        								.max(BigDecimal::compareTo)
        								.orElse(BigDecimal.ZERO); // default 값으로 '0' 설정
        System.out.println(errorMaxAmount);
	}
}

 

cf) 읽으면 좋을 것 같은 글

https://jeong-pro.tistory.com/m/229

'Backend > Java8' 카테고리의 다른 글

#26 Advanced Stream - Find First / Find Any  (1) 2022.10.15
#25 Advanced Stream - All Match / Any Match  (0) 2022.10.14
#23 Optional 응용 method  (0) 2022.10.12
#22 Optional(있을 수도 or 없을 수도 = null일 수도 or 아닐수도)  (0) 2022.10.11
#21 Stream - flatMap(스트림의 스트림을 납작하게)  (0) 2022.10.10
공지사항
최근에 올라온 글
최근에 달린 댓글
Total
Today
Yesterday
링크
TAG more
«   2025/09   »
일 월 화 수 목 금 토
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30
글 보관함