Java Collectors.toMap方法代码示例

import java.util.stream.Collectors; //导入方法依赖的package包/类
/**
 * Return a Collector that collects to a TreeMap using the supplied key and value mappers. Duplicate keys will
 * result in a {@link RuntimeException}. Useful for creating sorted maps to go into HealthCheck detail values
 */
static <T, K, U> Collector<T, ?, TreeMap<K, U>> buildTreeMapCollector(
        Function<? super T, ? extends K> keyMapper,
        Function<? super T, ? extends U> valueMapper) {

    return Collectors.toMap(
            keyMapper,
            valueMapper,
            (v1, v2) -> {
                throw new RuntimeException(String.format("Duplicate key for values %s and %s", v1, v2));
            },
            TreeMap::new);
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
public static <T, K, U> Collector<T, ?, BiMap<K, U>> collectToBiMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {
    Collector<T, ?, BiMap<K, U>> x = Collectors.toMap(
            keyMapper, valueMapper,
            (u, v) -> {
                throw new RuntimeException("should not hapen: " + u + " --- map: " + v);
            },
            HashBiMap::create);
    return x;
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
public static <K, U, M extends Map<K, U>> Collector<Map.Entry<K, U>, ?, M> toMap(Supplier<M> mapSupplier) {
    return Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, throwingMerger(), mapSupplier);
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
public static <T, K, U> Collector<T, ?, Map<K, U>> toLinkedMap(Function<? super T, ? extends K> keyMapper,
                                                               Function<? super T, ? extends U> valueMapper) {
    return Collectors.toMap(keyMapper, valueMapper, (u, v) -> {
        throw new IllegalStateException(String.format("Duplicate key %s", u));
    }, LinkedHashMap::new);
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
public static <K, U> Collector<Map.Entry<K, U>, ?, Map<K, U>> entriesToMap() {
    return Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue);
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
public static <A,B> Collector<Pair<A,B>,?,Map<A,B>> pairsToMap(){
	return Collectors.toMap(Pair::getLeft, Pair::getRight);
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
public static <A,B> Collector<Entry<A,B>,?,Map<A,B>> entriesToMap(){
	return Collectors.toMap(Entry::getKey, Entry::getValue);
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
public static <K, U> Collector<Map.Entry<K, U>, ?, Map<K, U>> entriesToMap() {
    return Collectors.toMap((e) -> e.getKey(), (e) -> e.getValue());
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
/**
 * Returns a {@code Collector} that accumulates the input elements into a new {@code LinkedHashMap}.
 *
 * @param keyTransformation   the transformation function used to derive a resulting entry key from each item
 * @param valueTransformation the transformation function used to derive a resulting entry value from each item
 * @param <T>                 the type of the input elements
 * @param <K>                 the type of the output map keys
 * @param <V>                 the type of the output map values
 * @return a new collector that accumulates the input elements into a new {@code LinkedHashMap}
 * @see #map()
 */
public static <T, K, V> Collector<T, ?, Map<K, V>> map(Function<? super T, ? extends K> keyTransformation,
                                                       Function<? super T, ? extends V> valueTransformation) {

	BinaryOperator<V> merger = throwingMerger();

	return Collectors.toMap(keyTransformation, valueTransformation, merger, New::map);
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
/**
 * Collects a stream of pairs into a map
 * @param <K> the left type of the pair, interpreted as the key type
 * @param <V> the right type of the pair, interpreted as the value type
 * @return a Collector which collects a Stream of Pairs into a Map
 */
static <K, V> Collector<Pair<K, V>, ?, Map<K, V>> toMap() {
    return Collectors.toMap(Pair::left, Pair::right);
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
/**
 * Converts entries to map.
 *
 * @param <K> Key type
 * @param <V> Value type
 * @return a collector
 */
public static <K, V> Collector<Entry<K, V>, ?, Map<K, V>> entriesToMap() {
  return Collectors.toMap((e) -> e.getKey(), (e) -> e.getValue());
}
 

import java.util.stream.Collectors; //导入方法依赖的package包/类
/**
 * Collect a stream of {@link Map.Entry} to a {@link Map} with the same key/value types
 * @param <K> the key type
 * @param <V> the value type
 * @return a map
 */
public static <K, V> Collector<Map.Entry<K, V>, ?, Map<K, V>> toMap() {
    return Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue);
}