4장 스트림 : 2부

// stream을 이용 Map<Dish.Type, List<Dish>> collect = Dish.DISHES.stream().collect(groupingBy(Dish :: getType)); /* 이렇듯 Dish.Type과 일치하는 모든 요리를 추출하는 함수를 groupingBy 메서드로 전달 했다. 이 함수를 기준으로 스트림이 그룹화되므로 이를 분류함수라고 부른다. */ // 외부 for을 이용 Map<Dish.Type,List<Dish>> dishMap = new HashMap<>(); for (Dish dish : Dish.DISHES){ dishMap.put(dish.getType(),new ArrayList<>()); } for (Dish dish : Dish.DISHES){ dishMap.get(dish.getType()).add(dish); }

Map<caloricLevel, List<Dish>> collect = Dish.DISHES.stream().collect(groupingBy(dish -> { int caloric = dish.getCalories(); return caloric >= 700 ? caloricLevel.FAT : (caloric < 700) && (caloric >= 400) ? caloricLevel.NORMAL : caloricLevel.DIET; })); /* result { DIET=[ Dish{name='rice', vegetarian=true, calories=350, type=OTHER}, Dish{name='season fruit', vegetarian=true, calories=120, type=OTHER}, Dish{name='prawns', vegetarian=false, calories=300, type=FISH} ], NORMAL=[ Dish{name='chicken', vegetarian=false, calories=400, type=MEAT}, Dish{name='pizza', vegetarian=true, calories=550, type=MY_DISH}, Dish{name='salmon', vegetarian=false, calories=450, type=FISH} ], FAT=[ Dish{name='pork', vegetarian=false, calories=800, type=MEAT}, Dish{name='beef', vegetarian=false, calories=700, type=MEAT} ] } */

// 하지만 문제가 있다. Map<Dish.Type, List<Dish>> collect = Dish.DISHES.stream() .filter(dish -> dish.getCalories() > 500) .collect(groupingBy(Dish::getType)); /* 문제점 나는 모든 타입을 원하지만 filter를 통하여 타입이 걸러지는 문제 { MY_DISH=[ Dish{name='pizza', vegetarian=true, calories=550, type=MY_DISH} ], MEAT=[ Dish{name='pork', vegetarian=false, calories=800, type=MEAT}, Dish{name='beef', vegetarian=false, calories=700, type=MEAT} ] } 이러한 문제점을 해결하기 위해서 Collectors 클래스는 일반적인 분류 함수에 Collector 형식의 두번째 인수를 갖도록 groupingBy 팩터리 메서드를 오버로드 이문제를 해결한다. */ // filtering 지원 Map<Dish.Type, List<Dish>> collect = Dish.DISHES.stream() .collect(groupingBy(Dish::getType, filtering(dish -> dish.getCalories() > 500, toList()))); /* public static <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) { return groupingBy(classifier, HashMap::new, downstream); } -> 이러한 메소드로 타고 들어가서 다시한번 다른 groupingBy를 실행시킴 이까지는 이해하겠는데 한번 더 들어가는 과정에서 솔직히 이해하기가 힘들다. Collector 타입의 메소드를 accumulator() 해주는 과정을 통해서 추출하는 것 같음 */ // mapping 지원 Map<Dish.Type, List<String>> collect = Dish.DISHES.stream() .collect(groupingBy(Dish::getType, mapping(Dish::getName, toList()))); /* result { MEAT=[pork, beef, chicken], FISH=[prawns, salmon], OTHER=[rice, season fruit], MY_DISH=[pizza] } */ // flatMapping 지원 // List<String> -> Set<String> public static Map<String, List<String>> dishTags = new HashMap<>(); public static void main(String[] args) { dishTags.put("pork",asList("greasy", "salty")); dishTags.put("beef",asList("salty", "roasted")); dishTags.put("chicken",asList("fried", "crisp")); dishTags.put("french fries",asList("greasy", "fried")); dishTags.put("rice",asList("light", "natural")); dishTags.put("season fruit",asList("fresh", "natural")); dishTags.put("pizza",asList("tasty", "salty")); dishTags.put("prawns",asList("tasty", "roasted")); dishTags.put("salmon",asList("delicious", "fresh")); Map<Dish.Type,Set<String>> dishNameByTags = Dish.DISHES.stream().collect( groupingBy(Dish::getType, flatMapping(dish -> dishTags.get(dish.getName()).stream(), toSet()) )); System.out.println(dishNameByTags.toString()); } // 다수준 그룹화 // 요리의 타입별로 칼로리레벨과 이름들을 나열하고 싶다. Map<Dish.Type,Map<CaloricLevel,List<String>>> dishesByTypeCaloricLevel = Dish.DISHES.stream().collect( groupingBy(Dish::getType, groupingBy(dish -> { int caloric = dish.getCalories(); return caloric >= 700 ? CaloricLevel.FAT : (caloric < 700) && (caloric >= 400) ? CaloricLevel.NORMAL : CaloricLevel.DIET; },mapping(Dish::getName,toList())))); System.out.println(dishesByTypeCaloricLevel.toString());

Map<Dish.Type, Optional<Dish>> collect = Dish.DISHES.stream().collect( groupingBy(Dish :: getType, maxBy(Comparator.comparingInt(Dish :: getCalories)))); /* 그런데 Optional<Dish>의 형으로 들어간다. 근데 실제로 생각해보면 groupingBy의 경우 없는 값은 Map의 키로 담지 않는다. 그렇기에 Optional 자체가 필요없다. */ Map<Dish.Type, Dish> collect = Dish.DISHES.stream().collect( groupingBy(Dish :: getType, collectingAndThen( // collecting이 끝난후 작업명시 maxBy(Comparator.comparingInt(Dish :: getCalories)), Optional::get))); // get 호출

List<Dish> useFilterCollect = Dish.DISHES.stream() .filter(Dish :: isVegetarian) .collect(toList()); Map<Boolean, List<Dish>> usePartitioningCollect = Dish.DISHES.stream() .collect(partitioningBy(Dish :: isVegetarian)); Map<Boolean, List<String>> usePartitioningMappingcollect = Dish.DISHES.stream() .collect(partitioningBy(Dish :: isVegetarian, mapping(Dish :: getName, toList()))); /* 분할의 장점은 무엇일까? 기본적으로 filter를 이용하면 참, 거짓 요소의 리스트를 유지하는 힘들다. 하지만 partitioning을 이용하면 true={}, false={} 요소 로 나타낼 수 있다. */ // 채식주의 메뉴 구별, 젤 높은 칼로리 값 찾기, 메뉴 이름으로 가져오기 Map<Boolean, String> collect = Dish.DISHES.stream() .collect( partitioningBy(Dish :: isVegetarian, collectingAndThen(maxBy(Comparator.comparingInt(Dish :: getCalories)), dish -> dish.get().getName()) )); System.out.println(collect.toString());

// Method Name : toList() // @return : List<T> // 스트림의 모든 항목을 리스트로 수집 List<Dish> collect = Dish.DISHES.stream().collect(Collectors.toList()); // Method Name : toSet() // @return : Set<T> // 스트림의 모든 항목을 집합으로 수집 Set<Dish> collect = Dish.DISHES.stream().collect(Collectors.toSet()); // Method Name : toCollection() // @return : Collection<T> // 스트림의 모든 항목을 발행자가 제공하는 컬렉션으로 수집 Collection<Dish> collect = Dish.DISHES.stream().collect(toCollection(HashSet ::new)); // Method Name : counting() // @return : Long // 스트림의 항목 수 계산 Long collect = Dish.DISHES.stream().collect(counting()); // Method Name : summing() // @return : Integer // 스트림의 항목에서 정수 프로퍼티 값을 더함 Integer collect = Dish.DISHES.stream().collect(summingInt(Dish :: getCalories)); // Method Name : averaging() // @return : Double // 스트림의 항목에서 정수 프로퍼티 값의 평균 계산 Double collect = Dish.DISHES.stream().collect(averagingInt(Dish :: getCalories)); // Method Name : summarizing() // @return : IntSummaryStatistics // 스트림의 항목에서 최대, 최소, 합계, 평균, 등 통계수집 IntSummaryStatistics collect = Dish.DISHES.stream().collect(summarizingInt(Dish :: getCalories)); System.out.println(collect); // Method Name : joining() // @return : String // 스트림의 항목에서 문자열 항목에서 toString()을 호출한 결과 결합 String collect = Dish.DISHES.stream().map(Dish :: getName).collect(joining(", ")); System.out.println(collect); // Method Name : maxBy(), minBy() // @return : Optional<T> // 스트림의 항목에서 주어진 비교자를 이용하여 스트림 요소의 최대값, 최소값을 Optional<T> 형태로 반환, 없을땐 Optional.empty() 반환 Optional<Dish> collect = Dish.DISHES.stream().collect(maxBy(Comparator.comparingInt(Dish :: getCalories))); Optional<Dish> collect = Dish.DISHES.stream().collect(minBy(Comparator.comparingInt(Dish :: getCalories))); // Method Name : reducing() // @return : T // 누적자를 초깃값으로 설정, 다음에 BinaryOperator로 스트림의 각 요소를 반복적으로 누적자와 합쳐 스트림을 하나의 값으로 리듀싱 Integer collect = Dish.DISHES.stream().collect(reducing(0, Dish :: getCalories, Integer :: sum)); // Method Name : collectingAndThen() // @return : ? // 다른 컬렉터를 감싸고 그 결과에 변환 함수 적용 Long collect = Dish.DISHES.stream().collect( collectingAndThen( summarizingInt(Dish :: getCalories), IntSummaryStatistics :: getSum)); // Method Name : groupingBy() // @return : Map<K, List<T>> // 하나의 프로퍼티값을 기준으로 스트림의 항목을 그룹화하며 기준 프로퍼티값을 결과 맵의 키로 사용 Map<Dish.Type, List<Dish>> collect = Dish.DISHES.stream() .collect( groupingBy(Dish :: getType) ); // Method Name : partitioningBy() // @return : Map<Boolean, List<T>> // 프레디케이트를 스트림의 각 항목에 적용한 결과로 항목 분할 Map<Dish.Type, Map<Boolean, List<Dish>>> collect = Dish.DISHES.stream() .collect( groupingBy(Dish :: getType, partitioningBy(Dish :: isVegetarian)) ); System.out.println(collect);

// Collector 인터페이스 /* T 수집될 스트림 항목의 형식 A 누적자, 수집과정에서 중간결과를 누적하는 객체의 형식 R 수집 연산의 결과 객체 형식 */ public interface Collector<T, A, R> { /* 빈 누적자 인스턴스를 만드는 함수 즉, A를 만드는 과정 */ Supplier<A> supplier(); /* reducing 연산을 수행하는 함수를 반환 A.add(T) 라고 보면 된다. 여기를 함수 반화으로 생각해보면 A.add(T)를 해주는 연산자를 반환 */ BiConsumer<A, T> accumulator(); /* 조합자로서 두 누적자가 이결과를 어떻게 처리할지 결정한다. 예를 들어 서브파트를 병렬로 처리할 경우 */ BinaryOperator<A> combiner(); /* 스트림 탐색을 끝내고 누적자 객체를 최종 결과로 변환하면서 누적 과정을 끝낼 때 호출할 함수를 반환, 같은 타입이면 객체 변환이 필요없기 때문에 Fuction.identity() 항등함수를 반환 */ Function<A, R> finisher(); /* collect 메서드가 어떤최적화(병렬화 같은)를 이용해서 리듀싱 연산을 수행할지 결정하도록 돕는 힌트 */ Set<Characteristics> characteristics(); /* UNODERED : 리듀싱 결과는 순서의 영향을 받지않는다. CONCURRENT : 다중 스레드에서 accumulator 함수를 동시 호출가능 병렬 리듀싱 가능 UNODERED와 같이 사용하거나 사용하지 않는다면 순서와 상관없어야함 IDENTITY_FINISH : identity를 적용할 뿐이므로 이를 생략가능. */

public class ToListCollector<T> implements Collector<T,List<T>,List<T>>{ @Override public Supplier<List<T>> supplier() { return ArrayList::new; } @Override public BiConsumer<List<T>, T> accumulator() { return List::add; } @Override public BinaryOperator<List<T>> combiner() { return (list1, list2) -> {list1.addAll(list2); return list1;}; } @Override public Function<List<T>, List<T>> finisher() { return Function.identity(); } @Override public Set<Characteristics> characteristics() { return Collections.unmodifiableSet(EnumSet.of(Characteristics.IDENTITY_FINISH, Characteristics.CONCURRENT)); } } // main ... ArrayList<Dish> collect = Dish.DISHES.stream().collect( new ToListCollector()); // other ... ArrayList<Dish> collect = Dish.DISHES.stream().collect( ArrayList :: new, ArrayList :: add, ArrayList :: addAll); System.out.println(collect);