반응형
1. 자주 사용되는 연산자 상세 설명
1.1 sorted() - 정렬
sorted() 연산자는 스트림의 요소를 정렬할 때 사용합니다. 자연 순서(natural order)나 커스텀 Comparator를 사용할 수 있습니다.
public class Product {
private String name;
private BigDecimal price;
private String category;
// 생성자, getter, setter 생략
}
// 기본 정렬 (자연 순서)
List<String> sortedNames = products.stream()
.map(Product::getName)
.sorted()
.collect(Collectors.toList());
// 가격 기준 내림차순 정렬
List<Product> expensiveFirst = products.stream()
.sorted(Comparator.comparing(Product::getPrice).reversed())
.collect(Collectors.toList());
// 복합 조건 정렬: 카테고리 오름차순, 같은 카테고리 내에서는 가격 내림차순
List<Product> complexSorted = products.stream()
.sorted(Comparator
.comparing(Product::getCategory)
.thenComparing(Product::getPrice, Comparator.reverseOrder()))
.collect(Collectors.toList());1.2 distinct() - 중복 제거
distinct()는 스트림에서 중복된 요소를 제거합니다. 객체의 경우 equals()와 hashCode() 메서드를 기준으로 판단합니다.
// 기본 타입의 중복 제거
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 4);
List<Integer> distinctNumbers = numbers.stream()
.distinct()
.collect(Collectors.toList()); // [1, 2, 3, 4]
// 객체의 특정 필드 기준 중복 제거
List<Product> uniqueCategories = products.stream()
.map(Product::getCategory)
.distinct()
.collect(Collectors.toList());
// 복합 키를 기준으로 중복 제거
List<Product> distinctByNameAndCategory = products.stream()
.collect(Collectors.collectingAndThen(
Collectors.toMap(
p -> p.getName() + "|" + p.getCategory(), // 복합 키 생성
Function.identity(),
(existing, replacement) -> existing // 중복 시 기존 값 유지
),
map -> new ArrayList<>(map.values())
));1.3 limit()와 skip() - 페이징 처리
데이터를 일정 단위로 나누어 처리할 때 유용합니다.
// 페이징 처리 유틸리티
public class StreamPaging<T> {
public List<T> getPage(Stream<T> stream, int pageSize, int pageNumber) {
return stream
.skip((long) pageSize * (pageNumber - 1))
.limit(pageSize)
.collect(Collectors.toList());
}
}
// 사용 예제
StreamPaging<Product> paging = new StreamPaging<>();
List<Product> page1 = paging.getPage(products.stream(), 10, 1); // 첫 10개
List<Product> page2 = paging.getPage(products.stream(), 10, 2); // 다음 10개1.4 flatMap() - 중첩 구조 평탄화
flatMap()은 스트림의 각 요소를 다른 스트림으로 변환한 후, 모든 스트림을 하나의 스트림으로 평탄화합니다.
public class Order {
private List<OrderItem> items;
// 다른 필드와 메서드 생략
}
public class OrderItem {
private String productId;
private int quantity;
// 다른 필드와 메서드 생략
}
// 모든 주문에서 주문된 상품 ID 목록 추출
List<String> allProductIds = orders.stream()
.flatMap(order -> order.getItems().stream())
.map(OrderItem::getProductId)
.distinct()
.collect(Collectors.toList());
// 2차원 배열을 1차원으로 평탄화
String[][] arrays = {{"a", "b"}, {"c", "d"}, {"e", "f"}};
List<String> flatList = Arrays.stream(arrays)
.flatMap(Arrays::stream)
.collect(Collectors.toList()); // [a, b, c, d, e, f]2. Collectors 클래스 활용
2.1 기본 수집 연산
// List로 수집
List<String> nameList = products.stream()
.map(Product::getName)
.collect(Collectors.toList());
// Set으로 수집
Set<String> categorySet = products.stream()
.map(Product::getCategory)
.collect(Collectors.toSet());
// Map으로 수집
Map<String, Product> productMap = products.stream()
.collect(Collectors.toMap(
Product::getName, // 키 매퍼
Function.identity(), // 값 매퍼
(existing, replacement) -> existing // 중복 키 처리
));2.2 그룹화와 분할
// 카테고리별 상품 목록
Map<String, List<Product>> byCategory = products.stream()
.collect(Collectors.groupingBy(Product::getCategory));
// 카테고리별 평균 가격
Map<String, Double> avgPriceByCategory = products.stream()
.collect(Collectors.groupingBy(
Product::getCategory,
Collectors.averagingDouble(p -> p.getPrice().doubleValue())
));
// 가격대별 상품 수
Map<String, Long> productCountByPriceRange = products.stream()
.collect(Collectors.groupingBy(
product -> {
BigDecimal price = product.getPrice();
if (price.compareTo(new BigDecimal("10000")) < 0) return "저가";
if (price.compareTo(new BigDecimal("50000")) < 0) return "중가";
return "고가";
},
Collectors.counting()
));
// 고가/저가 상품 분류
Map<Boolean, List<Product>> partitionedProducts = products.stream()
.collect(Collectors.partitioningBy(
p -> p.getPrice().compareTo(new BigDecimal("50000")) >= 0
));2.3 복합 수집 연산
// 카테고리별 통계
public class CategoryStats {
private long count;
private BigDecimal minPrice;
private BigDecimal maxPrice;
private BigDecimal avgPrice;
// 생성자, getter, setter 생략
}
Map<String, CategoryStats> categoryStats = products.stream()
.collect(Collectors.groupingBy(
Product::getCategory,
Collectors.collectingAndThen(
Collectors.toList(),
productList -> {
DoubleSummaryStatistics stats = productList.stream()
.mapToDouble(p -> p.getPrice().doubleValue())
.summaryStatistics();
return new CategoryStats(
stats.getCount(),
BigDecimal.valueOf(stats.getMin()),
BigDecimal.valueOf(stats.getMax()),
BigDecimal.valueOf(stats.getAverage())
);
}
)
));3. Optional과 Stream의 조합
3.1 Optional 스트림 처리
public class Order {
private String id;
private Optional<Customer> customer; // 비회원 주문 가능
// 다른 필드와 메서드 생략
}
// Optional 값이 있는 경우만 처리
List<Customer> validCustomers = orders.stream()
.map(Order::getCustomer)
.filter(Optional::isPresent)
.map(Optional::get)
.collect(Collectors.toList());
// flatMap을 사용한 더 나은 방식
List<Customer> validCustomers = orders.stream()
.map(Order::getCustomer)
.flatMap(Optional::stream) // Java 9+
.collect(Collectors.toList());3.2 Optional 활용 예제
public class OrderProcessor {
public Optional<OrderSummary> processMemberOrder(Order order) {
return Optional.of(order)
.filter(o -> o.getCustomer().isPresent())
.map(o -> new OrderSummary(
o.getId(),
o.getCustomer().get().getName(),
calculateTotal(o)
));
}
private BigDecimal calculateTotal(Order order) {
return order.getItems().stream()
.map(item -> item.getPrice().multiply(new BigDecimal(item.getQuantity())))
.reduce(BigDecimal.ZERO, BigDecimal::add);
}
}마무리
이번 포스트에서는 Stream API의 중급 활용법에 대해 알아보았습니다. 특히 Collectors의 다양한 활용법과 Optional과의 조합을 통해 더 강력한 데이터 처리가 가능함을 살펴보았습니다. 다음 포스트에서는 Stream API의 고급 활용법과 성능 최적화 방법에 대해 알아보도록 하겠습니다.
반응형