=== I groupingBy ===
groupingBy(Function)
E' il più semplice: gli elementi dello stream vengono mappati a qualche chiave tramite il valore di ritorno della Function.
Ritorna una Map<K, List<T>> dove le chiavi sono i valori di ritorno della Function applicata agli elementi in input dello stream, mentre i corrispondenti valori sono Lists contenenti gli elementi in input la quale mappatura è associata ad una chiave della mappa.
E' sempre più facile a farsi che a dirsi.
List<String> lst = Arrays.asList("qui", "quo", "qua", "pluto", "pippo", "galaca", "goku", "lamu");
Map<Integer,List<String>> m = lst.stream().collect(
Collectors.groupingBy(String::length)
);
System.out.println(m);
=== II groupingBy ===
groupingBy(Function, Collector)
La Function mappa gli elementi dello stream ad una chiave K, mentre il downstream collector opera sugli elementi e produce
un risultato di tipo D. Il risultato sarà una Map<K,D>
List<String> nomiFrutti = Arrays.asList("qui", "quo", "qua", "pluto", "pippo", "galaca", "goku", "lamu");
Map<Character,Set<String>> m= nomiFrutti.stream().collect(
Collectors.groupingBy(s->s.charAt(0) , Collectors.mapping(s->s+" "+s.length(), toSet()))
);
System.out.println(m);
=== III groupingBy ===
groupingBy(Function, Suppliet, Collector)
Il terzo groupingBy è facile da comprendere se capiti bene i precedenti.
La Function mappa sempre gli elementi in input dello stream in key della mappa.
Il Collector opera sempre sugli elementi dello stream producento un risultato di tipo D che sarà il valore della chiave dell'elemento.
Il Supplier produce una nuova mappa vuota del tipo desiderato.
//imposta le chiavi nel loro ordinamento naturale
Map<Character,String> m= lst.stream().collect(
Collectors.groupingBy(s -> s.charAt(0), TreeMap::new , Collectors.joining("/"))
);
//imposta le chiavi in un ordinamento casuale
Map<Character,String> m= lst.stream().collect(
Collectors.groupingBy(s -> s.charAt(0), HashMap::new , Collectors.joining("/"))
);
Quindi volendo è possibile creare un Comparator per effettuare un desiderato ordinamento e farlo ritornare dal Supplier
Map<Character,String> m= lst.stream().collect(
Collectors.groupingBy(s -> s.charAt(0), ()->{return new TreeMap(MioComparatore);} , Collectors.joining("/"))
);
Adesso mi è leggermente più chiaro, anche se tanti meccanismi di base sugli stream mi sembrano ancora esoterici.
Perchè hanno inventato gli stream? Rispecchia molto il pattern Build.
Si pensa che sia più facile da comprendere?? Saranno molto utilizzati da ora in avanti??
Fatto sta che sono geniali