[Java] Remarque sur les collecteurs de flux

Notes personnelles

• Décrivez les modèles susceptibles d'être utilisés parce que vous les oublierez
• Peut-être que vous pouvez créer votre propre classe / méthode Collectors pour les modèles que vous utilisez souvent

Collectors#toMap()

Je veux utiliser LinkedHashMap

Je veux utiliser LikedHashMap explicitement. En passant, je souhaite autoriser les clés en double.

	public static <T, K, V> Collector<T, ?, Map<K, V>> toMap(
			Function<? super T, ? extends K> keyMapper,
			Function<? super T, ? extends V> valueMapper) {

		return Collectors.toMap(
				keyMapper,
				valueMapper,
				(a, b) -> b,
				LinkedHashMap::new);
	}

Lancez une exception si vous ne souhaitez pas autoriser les clés en double.

(a, b) -> { throw new IllegalStateException(～); }

Voir les collecteurs standard à deux arguments # toMap () pour plus de détails.

Je souhaite utiliser TreeMap

Je veux trier naturellement par clé. presque la même.

	public static <T, K, V> Collector<T, ?, Map<K, V>> toTreeMap(
			Function<? super T, ? extends K> keyMapper,
			Function<? super T, ? extends V> valueMapper) {

		return Collectors.toMap(
				keyMapper,
				valueMapper,
				(a, b) -> b,
				TreeMap::new); //★ Ici
	}

Lorsque vous souhaitez spécifier Composer pour TreeMap, spécifiez-le avec une expression lambda au lieu d'une référence de constructeur.

Collectors#toSet()

Je souhaite utiliser LinkedHashSet

Le point ici est d'utiliser toCollection () au lieu de toSet ().

	public static <T> Collector<T, ?, Set<T>> toSet() {
		return Collectors.toCollection(LinkedHashSet::new);
	}

Je souhaite utiliser TreeSet

Fondamentalement la même chose.

	public static <T> Collector<T, ?, Set<T>> toTreeSet() {
		return Collectors.toCollection(TreeSet::new);
	}

Collectors#groupingBy

Je veux utiliser LinkedHashMap

	public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(
			Function<? super T, ? extends K> classifier) {

		return Collectors.groupingBy(classifier,
				LinkedHashMap::new, //★ Ici
				Collectors.toList());
	}

Je souhaite utiliser TreeMap

le même.

	public static <T, K> Collector<T, ?, Map<K, List<T>>> orderedGroupBy(
			Function<? super T, ? extends K> classifier) {

		return Collectors.groupingBy(classifier,
				TreeMap::new, //★ Ici
				Collectors.toList());
	}

Je veux que l'élément soit un ensemble au lieu d'une liste

... Je ne peux pas penser à un bon nom de méthode.

	public static <T, K> Collector<T, ?, Map<K, Set<T>>> groupingBySet(
			Function<? super T, ? extends K> classifier) {

		return Collectors.groupingBy(classifier,
				TreeMap::new,
				Collectors.toCollection(LinkedHashSet::new)); //★ Ici
	}

Bien sûr, TreeSet ou Collectors.toSet () ordinaire peuvent être utilisés selon le but.

Je souhaite également convertir les éléments à emballer dans la liste lors du regroupement

	public static <T, K, D> Collector<T, ?, Map<K, List<D>>> groupingBy(
			Function<? super T, ? extends K> classifier,
			Function<? super T, ? extends D> mapper) {

		return Collectors.groupingBy(classifier,
				LinkedHashMap::new,
				Collectors.mapping(mapper, //★ Ici
						Collectors.toList()));
	}

Bien sûr, vous pouvez utiliser Set au lieu de List.

Collectors#collectingAndThen

Si vous souhaitez générer une carte ou une liste immuable.

	public static <T, K, V> Collector<T, ?, Map<K, V>> toConstMap(
			Function<? super T, ? extends K> keyMapper,
			Function<? super T, ? extends V> valueMapper) {

		return Collectors.collectingAndThen(
				Collectors.toMap(
					keyMapper,
					valueMapper),
				Collections::unmodifiableMap);
	}