Collectors. Raoul-Gabriel Urma Richard Warburton James Gough

Transcription

1 Collectors Raoul-Gabriel Urma Richard Warburton James Gough

2 Outline of module 1. Grouping and partitioning 2. Collection operations 3. Arithmetic and reducing collectors 4. Advanced queries

3 Grouping and partitioning

4 Collectors Most terminal operations that you ve seen so far were returning a single value E.g. boolean, int collect(tolist()) was returning a List collect takes a recipe to accumulate the elements of a stream into a container This recipe is a Collector object and is the parameter passed to the method collect

5 Collectors are fun and expressive (1) Map<Currency, List<Transaction>> transactionsbycurrencies = new HashMap<>(); for (Transaction transaction : transactions) { Currency currency = transaction.getcurrency(); List<Transaction> transactionsforcurrency = transactionsbycurrencies.get(currency); } if (transactionsforcurrency == null) { transactionsforcurrency = new ArrayList<>(); transactionsbycurrencies.put(currency, transactionsforcurrency); } transactionsforcurrency.add(transaction);

6 Collectors are fun and expressive (2) import static java.util.stream.collectors.groupingby; Map<Currency, List<Transaction>> transactionsbycurrencies = transactions.stream().collect(groupingby(transaction::getcurrency)); Reads like problem statement can be parallelised by using the method parallelstream

7 Grouping "GROUP BY" operation inspired from SQL Groups Stream elements according to a classification function, and returns the results in a Map. Map<Dish.Type, List<Dish>> dishesbytype = menu.stream().collect(groupingby(dish::gettype));

8 Partitioning Special case of grouping, which takes a partitioning function A partitioning function is a Predicate (a function that returns a boolean) Map<Boolean, List<Dish>> vegetariandishesbytype = menu.stream().collect(partitioningby(dish::isvegetarian)); { } false=[pork, beef, chicken, prawns, salmon], true=[french fries, rice, season fruit, pizza]

9 Exercise 1. Partition the list of dishes Dishes with calories > Group the list of dishes by CaloricLevel public enum CaloricLevel { DIET, NORMAL, FAT } 0 < DIET <= 400 calories 400 < NORMAL <= 700 FAT > 700 com.java_8_training.problems.collectors.partitioningandgroupingtest

10 Collection Operations

11 Collecting to lists and sets You ve seen tolist() already: List<Dish> dish = menu.stream().filter(dish::isvegetarian).collect(tolist()); You can also use toset(): Set<Dish> dish = menu.stream().filter(dish::isvegetarian).collect(toset());

12 Flexible collection You can use tocollection(supplier) for more flexibility Deque<Dish> dish = menu.stream().filter(dish::isvegetarian).collect(tocollection(arraydeque::new));

13 Exercise How would you remove duplicates from a list of numbers using Streams operations using a collector How would you transform a Stream into a TreeSet? com.java_8_training.problems.collectors. CollectTest

14 Arithmetic and reducing Collectors

15 Maximum and minimum Comparator<Dish> dishcaloriescomparator = Comparator.comparingInt(Dish::getCalories); Optional<Dish> mostcalorificdish = menu.stream().collect(maxby(dishcaloriescomparator)); Optional<Dish> leastcalorificdish = menu.stream().collect(minby(dishcaloriescomparator));

16 Counting long howmanydishes = menu.stream().collect(counting()); long howmanydishes = menu.stream().count(); The counting Collector can be useful especially when used in combination with other Collectors, as we ll demonstrate later.

17 Sum and Average Sum the values of using an extraction function which returns a number. (summingint, summinglong, summingdouble) int totalcalories = menustream.collect(summingint(dish::getcalories)); Calculate the average value using an extraction function which returns a number. (averagingint, averaginglong, averagingdouble) int avgcalories = menustream.collect(averagingint(dish::getcalories));

18 Summary statistics Returns summary statistics in a single operation using an extraction function that returns a number summarizingint, summarizinglong, summarizingdouble IntSummaryStatistics menustatistics = menu.stream().collect(summarizingint(dish::getcalories)); IntSummaryStatistics{count=9, sum=4300, min=120, average= , max=800}

19 Joining Concatenate the Strings resulting from the invocation of the tostring method on each item of the Stream. Internally makes use of StringBuilder String shortmenu = menu.stream().map(dish::getname).collect(joining(", ")); pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon

20 Reducing - three args Reduce the stream to a single value. It takes three parameters: 1. Identity: initial value and/or the default result if there are no elements in the stream. 2. Transforming function: The reducing operation applies this function to all stream elements. 3. Aggregating function: the aggregating function is used to iteratively combine the mapped values. Useful for multi-level reductions (e.g. together with groupingby - more later) int totalcalories = menu.stream().collect(reducing(0, Dish::getCalories, Integer::sum));

21 Reducing - three args int totalcalories = menu.stream().collect(reducing(0, Dish::getCalories, Integer::sum));

22 Reducing (3) - one arg Comparator<Dish> dishcaloriescomparator = Comparator.comparingInt(Dish::getCalories); BinaryOperator<Dish> maxbycalories = BinaryOperator.maxBy(dishCaloriesComparator); Optional<Dish> mostcalorificdish = menu.stream().collect(reducing(maxbycalories));

23 Reducing (4) - two args int totalcalories = menu.stream().map(dish::getcalories).collect(reducing(0, Integer::sum));

24 Quiz Which of the following statements are correct using the reducing Collector? String shortmenu = menu.stream().map(dish::getname).collect( reducing( (s1, s2) -> s1 + s2) ) ).get(); String shortmenu = menu.stream().collect( reducing( (d1, d2) -> d1.getname() + d2.getname() ) ).get(); String shortmenu = menu.stream().collect( reducing( "", Dish::getName, (s1, s2) -> s1 + s2) ) );

25 Exercise 1. Find the least caloric dish that is of type MEAT 2. Return statistics (average, sum, min, max) of the calories of vegetarian dishes com.java_8_training.problems.collectors. ArithmeticAndReducingCollectorsTest

26 Advanced queries

27 Composing collectors (1) The collectors groupingby and partitioningby accept other collectors as argument to create more complex queries. Map<Dish.Type, Long> typescount = menu.stream().collect( groupingby(dish::gettype, counting())); produces: {MEAT=3, FISH=2, OTHER=4}

28 Composing collectors (2) Map<Dish.Type, Integer> totalcaloriesbytype = menu.stream().collect( groupingby(dish::gettype, summingint(dish::getcalories)) );

29 Composing collectors (3) Map<Dish.Type, Optional<Dish>> mostcaloricbytype = menu.stream().collect(groupingby(dish::gettype, maxby(comparingint(dish::getcalories))));

30 Exercise Generate a Map of occurrences of characters in a sentence E.g. cool -> { c :1, o :2, l :1} Can you extend it to work with a List of sentences? com.java_8_training.problems.collectors. OccurrencesTest

31 collectingandthen (1) Wraps another Collector and apply a transformation function to its result. int howmanydishes = menustream.collect(collectingandthen(tolist(), List::size));

32 collectingandthen(2) Map<Dish.Type, Optional<Dish>> mostcaloricbytype = menu.stream().collect(groupingby(dish::gettype, maxby(comparingint(dish::getcalories)))); VS Map<Dish.Type, Dish> mostcaloricbytype = menu.stream().collect( groupingby(dish::gettype, collectingandthen( maxby(comparingint(dish::getcalories)), Optional::get)));

33 Multi-level groupings (1)

34 Multi-level groupings (2) enum CaloricLevel { DIET, NORMAL, FAT }; CaloricLevel getcaloriclevel() { if (getcalories() <= 400) return CaloricLevel.DIET; else if (getcalories() <= 700) return CaloricLevel.NORMAL; else return CaloricLevel.FAT; }

35 Multi-level groupings (3) Map<Dish.Type, Map<CaloricLevel, List<Dish>>> dishedbytypecaloriclevel = ); menu.stream().collect( groupingby(dish::gettype, ) groupingby(dish::getcaloriclevel)

36 Quiz What are the following doing? 1. menu.stream().collect(partitioningby(dish:: isvegetarian, partitioningby(d -> d.getcalories() > 500))); 2. menu.stream().collect(partitioningby(dish:: isvegetarian, partitioningby(dish::gettype))); 3. menu.stream().collect(partitioningby(dish:: isvegetarian, counting()));

37 Optional Exercise: Financial data processing

38 Exercise Continuation of trader and transactions unit tests Look at test: com.java_8_training.problems.collectors. TransactionsAndTradesPart2Test

39 Mutable reduction (Optional)

40 Collect vs. Reduce Reduce is an immutable reduction combine values and produce a new value Collect is a mutable reduction accumulates elements into a container Collectors let you abstract and re-use reduction strategies

41 Reduce - what s the problem? Stream<Integer> stream = Arrays.asList(1, 2, 3, 4, 5, 6). stream(); List<Integer> numbers = stream.reduce( new ArrayList<Integer>(), (List<Integer> l, Integer e) -> { l.add(e); return l; }, (List<Integer> l1, List<Integer> l2) -> { l1.addall(l2); return l1; });

42 Collect Stream<Integer> stream = Arrays.asList(1, 2, 3, 4, 5, 6). stream(); List<Integer> numbers = stream.collect(arraylist::new, List::add, List::addAll);

43 Implementing a Collector public interface Collector<T, A, R> { Supplier<A> supplier(); BiConsumer<A, T> accumulator(); Function<A, R> finisher(); BinaryOperator<A> combiner(); Set<Characteristics> characteristics(); }

44

45 ToListCollector public class ToListCollector<T> implements Collector<T, List<T>, List<T>> { } public Supplier<List<T>> supplier() { } return () -> new ArrayList<T>(); public BiConsumer<List<T>, T> accumulator() { } return (list, item) -> list.add(item); public Function<List<T>, List<T>> finisher() { } return Function.identity(); public BinaryOperator<List<T>> combiner() { } return (list1, list2) -> { }; list1.addall(list2); return list1;

46 public Supplier<List<T>> supplier() { } return () -> new ArrayList<T>();

47 public BiConsumer<List<T>, T> accumulator() { return (list, item) -> list.add(item); }

48 public Function<List<T>, List<T>> finisher() { } return Function.identity();

49 public BinaryOperator<List<T>> combiner() { return (list1, list2) -> { list1.addall(list2); return list1; }; }

50 Use your collector Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6) List<Integer> numbers = stream.collect(new ToListCollector<>());