[Java] Stream Collectors Hinweis

Persönliche Notizen

• Beschreiben Sie Muster, die wahrscheinlich verwendet werden, weil Sie sie vergessen werden
• Vielleicht können Sie Ihre eigene Collectors-Klasse / -Methode für die häufig verwendeten Muster erstellen

Collectors#toMap()

Ich möchte LinkedHashMap verwenden

Ich möchte LikedHashMap explizit verwenden. Ich möchte übrigens doppelte Schlüssel zulassen.

	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);
	}

Lösen Sie eine Ausnahme aus, wenn Sie keine doppelten Schlüssel zulassen möchten.

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

Weitere Informationen finden Sie in den Standard-Collectors # toMap () mit zwei Argumenten.

Ich möchte TreeMap verwenden

Ich möchte natürlich nach Schlüssel sortieren. fast das gleiche.

	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); //★ Hier
	}

Wenn Sie Comparator für TreeMap angeben möchten, geben Sie es mit einem Lambda-Ausdruck anstelle einer Konstruktorreferenz an.

Collectors#toSet()

Ich möchte LinkedHashSet verwenden

Hier geht es darum, toCollection () anstelle von toSet () zu verwenden.

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

Ich möchte TreeSet verwenden

Grundsätzlich das gleiche.

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

Collectors#groupingBy

Ich möchte LinkedHashMap verwenden

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

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

Ich möchte TreeMap verwenden

das Gleiche.

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

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

Ich möchte, dass das Element ein Set anstelle einer Liste ist

... Ich kann mir keinen guten Methodennamen vorstellen.

	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)); //★ Hier
	}

Natürlich können je nach Verwendungszweck TreeSet oder gewöhnliche Collectors.toSet () verwendet werden.

Ich möchte auch die Elemente konvertieren, die beim Gruppieren in die Liste gepackt werden sollen

	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, //★ Hier
						Collectors.toList()));
	}

Natürlich können Sie Set anstelle von List verwenden.

Collectors#collectingAndThen

Wenn Sie eine unveränderliche Karte oder Liste erstellen möchten.

	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);
	}