Guava源码解析十：Maps源码解析

构造方法

private Maps() {
}

私有的构造方法，可以看到这是一个真正的功能函数，下面对其函数进行分析

功能函数

返回一个不可变Map	1.ImmutableMap<K, V> immutableEnumMap(Map<K, ? extends V> map)
创建一个HashMap	1.HashMap<K, V> newHashMap() 2.HashMap<K, V> newHashMapWithExpectedSize(int expectedSize) 3.HashMap<K, V> newHashMap(Map<? extends K, ? extends V> map)
创建一个LinkedHashMap	1.LinkedHashMap<K, V> newLinkedHashMap() 2.LinkedHashMap<K, V> newLinkedHashMap(Map<? extends K, ? extends V> map)
创建一个ConcurrentMap	1.ConcurrentMap<K, V> newConcurrentMap()
创建一个TreeMap	1.TreeMap<K, V> newTreeMap() 2.TreeMap<K, V> newTreeMap(SortedMap<K, ? extends V> map) 3.TreeMap<K, V> newTreeMap(@Nullable Comparator<C> comparator)
创建一个EnumMap	1.EnumMap<K, V> newEnumMap(Class<K> type) 2.EnumMap<K, V> newEnumMap(Map<K, ? extends V> map)
创建一个IdentityHashMap	1.IdentityHashMap<K, V> newIdentityHashMap()
获取两个Map中不同元素的值	1.MapDifference<K, V> difference(Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right) 2.MapDifference<K, V> difference(Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right, Equivalence<? super V> valueEquivalence) 3.SortedMapDifference<K, V> difference(SortedMap<K, ? extends V> left, Map<? extends K, ? extends V> right)
根据函数和set，构造一个Map	1.Map<K, V> asMap(Set<K> set, Function<? super K, V> function) 2.SortedMap<K, V> asMap(SortedSet<K> set, Function<? super K, V> function) 3.NavigableMap<K, V> asMap(NavigableSet<K> set, Function<? super K, V> function)
根据函数和迭代器，构造一个不可变的Map	1.ImmutableMap<K, V> toMap(Iterator<K> keys, Function<? super K, V> valueFunction) 2.ImmutableMap<K, V> toMap(Iterator<K> keys, Function<? super K, V> valueFunction) 3. ImmutableMap<K, V> uniqueIndex(Iterable<V> values, Function<? super V, K> keyFunction) 4. ImmutableMap<K, V> uniqueIndex(Iterator<V> values, Function<? super V, K> keyFunction)
从配置文件中读取数据，创建一个不可变的Map	1.ImmutableMap<String, String> fromProperties(Properties properties)
返回一个Entry或一个Entry集合	1.Entry<K, V> immutableEntry(@Nullable K key, @Nullable V value) 2.Set<Entry<K, V>> unmodifiableEntrySet(Set<Entry<K, V>> entrySet) 3.Entry<K, V> unmodifiableEntry(final Entry<? extends K, ? extends V> entry)
返回一个特殊的BiMap类	1.BiMap<K, V> synchronizedBiMap(BiMap<K, V> bimap) 2.BiMap<K, V> unmodifiableBiMap(BiMap<? extends K, ? extends V> bimap)
根据一个Map和一个函数对Map进行转型	1.Map<K, V2> transformValues(Map<K, V1> fromMap, Function<? super V1, V2> function) 2.SortedMap<K, V2> transformValues(SortedMap<K, V1> fromMap, Function<? super V1, V2> function) 3.NavigableMap<K, V2> transformValues(NavigableMap<K, V1> fromMap, Function<? super V1, V2> function) 4.Map<K, V2> transformEntries(Map<K, V1> fromMap, Maps.EntryTransformer<? super K, ? super V1, V2> transformer) 5.SortedMap<K, V2> transformEntries(SortedMap<K, V1> fromMap, Maps.EntryTransformer<? super K, ? super V1, V2> transformer) 6.NavigableMap<K, V2> transformEntries(NavigableMap<K, V1> fromMap, Maps.EntryTransformer<? super K, ? super V1, V2> transformer)
自己写一个函数进行过滤Map，然后返回一个同类型的Map	分为4种过滤一、针对Key进行过滤 1.Map<K, V> filterKeys(Map<K, V> unfiltered, Predicate<? super K> keyPredicate) 2.SortedMap<K, V> filterKeys(SortedMap<K, V> unfiltered, Predicate<? super K> keyPredicate) 3.NavigableMap<K, V> filterKeys(NavigableMap<K, V> unfiltered, Predicate<? super K> keyPredicate) 4.BiMap<K, V> filterKeys(BiMap<K, V> unfiltered, Predicate<? super K> keyPredicate) 二、针对Value进行过滤 1.Map<K, V> filterValues(Map<K, V> unfiltered, Predicate<? super V> valuePredicate) 2.SortedMap<K, V> filterValues(SortedMap<K, V> unfiltered, Predicate<? super V> valuePredicate) 3.NavigableMap<K, V> filterValues(NavigableMap<K, V> unfiltered, Predicate<? super V> valuePredicate) 4.BiMap<K, V> filterValues(BiMap<K, V> unfiltered, Predicate<? super V> valuePredicate) 三、针对Entry进行过滤 1.Map<K, V> filterEntries(Map<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) 2.SortedMap<K, V> filterEntries(SortedMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) 3.SortedMap<K, V> filterSortedIgnoreNavigable(SortedMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) 4.NavigableMap<K, V> filterEntries(NavigableMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) 5.BiMap<K, V> filterEntries(BiMap<K, V> unfiltered, Predicate<? super Entry<K, V>> entryPredicate) 四、为含有过滤规则的Map进行过滤 1.Map<K, V> filterFiltered(Maps.AbstractFilteredMap<K, V> map, Predicate<? super Entry<K, V>> entryPredicate) 2.SortedMap<K, V> filterFiltered(Maps.FilteredEntrySortedMap<K, V> map, Predicate<? super Entry<K, V>> entryPredicate) 3.NavigableMap<K, V> filterFiltered(Maps.FilteredEntryNavigableMap<K, V> map, Predicate<? super Entry<K, V>> entryPredicate) 4.BiMap<K, V> filterFiltered(Maps.FilteredEntryBiMap<K, V> map, Predicate<? super Entry<K, V>> entryPredicate)

返回一个不可变Map

1.传入一个Map，返回一个不可变的Map容器

public static <K extends Enum<K>, V> ImmutableMap<K, V> immutableEnumMap(Map<K, ? extends V> map) {
    if(map instanceof ImmutableEnumMap) {
        //如果map为ImmutableEnumMap类型，直接强转为ImmutableEnumMap类型的容器
        ImmutableEnumMap i$1 = (ImmutableEnumMap)map;
        return i$1;
    } else if(map.isEmpty()) {
        //如果map为空，则直接返回新建的空的ImmutableMap容器
        return ImmutableMap.of();
    } else {
        Iterator i$ = map.entrySet().iterator();
        //在对map转型前，先判断其有没有属于null的key或value，如果有则直接抛出异常
        while(i$.hasNext()) {
            Entry entry = (Entry)i$.next();
            Preconditions.checkNotNull(entry.getKey());
            Preconditions.checkNotNull(entry.getValue());
        }
        //以上成立，则直接使用ImmutableEnumMap中函数为map进行转换
        return ImmutableEnumMap.asImmutable(new EnumMap(map));
    }
}

创建一个HashMap

1.直接返回一个新的HashMap

public static <K, V> HashMap<K, V> newHashMap() {
    return new HashMap();
}

2.返回一个想要长度的HashMap

public static <K, V> HashMap<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return new HashMap(capacity(expectedSize));
}

根据传入的长度，返回一个实际可用expectedSize的HashMap，capacity方法就是计算实际长度的一个方法，下面看一下capacity方法的源码：

static int capacity(int expectedSize) {
    if(expectedSize < 3) {
        CollectPreconditions.checkNonnegative(expectedSize, "expectedSize");
        return expectedSize + 1;
    } else {
        return expectedSize < 1073741824?expectedSize + expectedSize / 3:2147483647;
    }
}

可以看到根据expectedSize < 1073741824?expectedSize + expectedSize / 3:2147483647;公式，实际返回的是3/4的expectedSize。为什么3/4这个系数呢，这就得和HashMap的负载因子有关了，它的系数默认为3/4，即存储长度为实际长度的3/4时，就进行扩容。而我们实际想要的是expectedSize的长度。真正用到他的3/4的时候就会扩容，影响存储效率，我们将他的值变为原来的3/4，我们用到expectedSize的时候就不会扩容了。

3.传入一个Map型变量，返回一个HashMap

public static <K, V> HashMap<K, V> newHashMap(Map<? extends K, ? extends V> map) {
    return new HashMap(map);
}

对于传入的Map赋值给新的HashMap步骤就由HashMap的putMapEntries方法进行操作了。

创建一个LinkedHashMap

1.直接返回一个新的LinkedHashMap

public static <K, V> LinkedHashMap<K, V> newLinkedHashMap() {
    return new LinkedHashMap();
}

2.传入一个Map变量，返回一个LinkedHashMap

public static <K, V> LinkedHashMap<K, V> newLinkedHashMap(Map<? extends K, ? extends V> map) {
    return new LinkedHashMap(map);
}

对于传入的Map赋值给新的LinkedHashMap步骤就由LinkedHashMap的putMapEntries方法进行操作了。

创建一个ConcurrentMap

1.直接返回一个新的ConcurrentMap

public static <K, V> ConcurrentMap<K, V> newConcurrentMap() {
    return (new MapMaker()).makeMap();
}

可以看到他的ConcurrentMap是由MapMaker类进行创建的，下面我们看一下MapMaker的makeMap方法：

public <K, V> ConcurrentMap<K, V> makeMap() {
    return (ConcurrentMap)(!this.useCustomMap?new ConcurrentHashMap(this.getInitialCapacity(), 0.75F, this.getConcurrencyLevel()):(ConcurrentMap)(this.nullRemovalCause == null?new MapMakerInternalMap(this):new MapMaker.NullConcurrentMap(this)));
}

查看源码，因为并没有对useCustomMap字段修改为true的操作，所以此方法最终实际执行的语句为：

return new ConcurrentHashMap(this.getInitialCapacity(), 0.75F, this.getConcurrencyLevel())

查看其中两个函数的源码：

int getInitialCapacity() {
    return this.initialCapacity == -1?16:this.initialCapacity;
}
int getConcurrencyLevel() {
    return this.concurrencyLevel == -1?4:this.concurrencyLevel;
}

与useCustomMap字段同理，initialCapacity和concurrencyLevel变量并没有被设置，所以返回了默认值，initialCapacity为16，concurrencyLevel为4。所以最后创建一个长度为16，负载因子为0.75，并发级别为4的concurrentMap。

创建一个TreeMap

1.直接返回一个新的TreeMap

public static <K extends Comparable, V> TreeMap<K, V> newTreeMap() {
    return new TreeMap();
}

2.传入一个Map变量，返回一个TreeMap，并将Map的值赋值给TreeMap

public static <K, V> TreeMap<K, V> newTreeMap(SortedMap<K, ? extends V> map) {
    return new TreeMap(map);
}

3.传入一个比较接口，返回一个根据传入的比较规则形成的TreeMap

public static <C, K extends C, V> TreeMap<K, V> newTreeMap(@Nullable Comparator<C> comparator) {
    return new TreeMap(comparator);
}

创建一个EnumMap

1.传入一个Class变量，返回一个EnumMap

public static <K extends Enum<K>, V> EnumMap<K, V> newEnumMap(Class<K> type) {
    return new EnumMap((Class)Preconditions.checkNotNull(type));
}

2.传入一个Map变量，返回一个EnumMap

public static <K extends Enum<K>, V> EnumMap<K, V> newEnumMap(Map<K, ? extends V> map) {
    return new EnumMap(map);
}

对于传入的Map赋值给新的EnumMap步骤就由EnumMap的putAll方法进行操作了。

创建一个IdentityHashMap

1.直接返回一个identityHashMap

public static <K, V> IdentityHashMap<K, V> newIdentityHashMap() {
    return new IdentityHashMap();
}

identityHashMap，与HashMap不同之处在于可以存入相同类的相同值，实际上他在put里的添加操作是不是使用equals而是用的==进行判断的

获取两个Map中不同元素的值

在说明Maps中这三个方法之前，我们先了解一下MapDifference接口和的实现类MapDifferenceImpl可以表现什么吧：

MapDifference接口：

public interface MapDifference<K, V> {
    boolean areEqual();
    Map<K, V> entriesOnlyOnLeft();
    Map<K, V> entriesOnlyOnRight();
    Map<K, V> entriesInCommon();
    Map<K, MapDifference.ValueDifference<V>> entriesDiffering();
    boolean equals(@Nullable Object var1);
    int hashCode();
    public interface ValueDifference<V> {
        V leftValue();
        V rightValue();
        boolean equals(@Nullable Object var1);
        int hashCode();
    }
}

它的实现类：

static class MapDifferenceImpl<K, V> implements MapDifference<K, V> {
    final Map<K, V> onlyOnLeft;
    final Map<K, V> onlyOnRight;
    final Map<K, V> onBoth;
    final Map<K, ValueDifference<V>> differences;

    MapDifferenceImpl(Map<K, V> onlyOnLeft, Map<K, V> onlyOnRight, Map<K, V> onBoth, Map<K, ValueDifference<V>> differences) {
        this.onlyOnLeft = Maps.unmodifiableMap(onlyOnLeft);
        this.onlyOnRight = Maps.unmodifiableMap(onlyOnRight);
        this.onBoth = Maps.unmodifiableMap(onBoth);
        this.differences = Maps.unmodifiableMap(differences);
    }
    public boolean areEqual() {。。。}
    public Map<K, V> entriesOnlyOnLeft() {return this.onlyOnLeft; }
    public Map<K, V> entriesOnlyOnRight() {return this.onlyOnRight; }
    public Map<K, V> entriesInCommon() {return this.onBoth; }
    public Map<K, ValueDifference<V>> entriesDiffering() { return this.differences; }
    public boolean equals(Object object) {。。。}
    public int hashCode() {。。。}
    public String toString() {。。。}
}

可以看到MapDifferenceImpl实现类中有4个变量，根据字面意思便可以知道，onlyOnLeft只存变量名为left的Map中独有的；onlyOnRight只存变量名为right的Map中独有的；onBoth存储两个map中共有的key并且value也相等的元素；differences因为value存储的类型为ValueDifference，在查看MapDifference接口中ValueDifference类的结构，可以断定differences中存储的是共有的key并且value不同的元素

1.传入两个Map变量，根据left变量名的Map的类型进行判断是交给那个difference方法去处理

public static <K, V> MapDifference<K, V> difference(Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right) {
    if(left instanceof SortedMap) {
        SortedMap sortedLeft = (SortedMap)left;
        SortedMapDifference result = difference((SortedMap)sortedLeft, right);
        return result;
    } else {
        return difference(left, right, Equivalence.equals());
    }
}

2.传入两个Map，使用doDifference方法将两个Map中的元素进行分类

public static <K, V> MapDifference<K, V> difference(Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right, Equivalence<? super V> valueEquivalence) {
    Preconditions.checkNotNull(valueEquivalence);
    HashMap onlyOnLeft = newHashMap();
    HashMap onlyOnRight = new HashMap(right);
    HashMap onBoth = newHashMap();
    HashMap differences = newHashMap();
    doDifference(left, right, valueEquivalence, onlyOnLeft, onlyOnRight, onBoth, differences);
    return new Maps.MapDifferenceImpl(onlyOnLeft, onlyOnRight, onBoth, differences);
}

doDifference方法的源码：

private static <K, V> void doDifference(Map<? extends K, ? extends V> left, Map<? extends K, ? extends V> right, Equivalence<? super V> valueEquivalence, Map<K, V> onlyOnLeft, Map<K, V> onlyOnRight, Map<K, V> onBoth, Map<K, ValueDifference<V>> differences) {
    Iterator i$ = left.entrySet().iterator();
    //对left进行遍历操作
    while(i$.hasNext()) {
        Entry entry = (Entry)i$.next();
        Object leftKey = entry.getKey();
        Object leftValue = entry.getValue();
        //查看right中是否包括这个key值
        if(right.containsKey(leftKey)) {
            //如果right中也包括这个key值，则将这个值在right中去除
            Object rightValue = onlyOnRight.remove(leftKey);
            //判断这个key值的left和right的value值是否相等
            if(valueEquivalence.equivalent(leftValue, rightValue)) {
                //如果两个value值相等，将其填入onBoth的Map容器中
                onBoth.put(leftKey, leftValue);
            } else {
                //如果两个value值不相等，将其填入differences的Map容器中
                differences.put(leftKey, Maps.ValueDifferenceImpl.create(leftValue, rightValue));
            }
        } else {
            //如果这个key在right中不存在，则将其填入onlyOnLeft容器中
            onlyOnLeft.put(leftKey, leftValue);
        }
    }
}

3.传入一个SortedMap和一个Map变量，返回一个分类后的类

public static <K, V> SortedMapDifference<K, V> difference(SortedMap<K, ? extends V> left, Map<? extends K, ? extends V> right) {
    Preconditions.checkNotNull(left);
    Preconditions.checkNotNull(right);
    Comparator comparator = orNaturalOrder(left.comparator());
    TreeMap onlyOnLeft = newTreeMap((Comparator)comparator);
    TreeMap onlyOnRight = newTreeMap((Comparator)comparator);
    onlyOnRight.putAll(right);
    TreeMap onBoth = newTreeMap((Comparator)comparator);
    TreeMap differences = newTreeMap((Comparator)comparator);
    //根据以上的处理对两个Map中的元素进行分类处理
    doDifference(left, right, Equivalence.equals(), onlyOnLeft, onlyOnRight, onBoth, differences);
    return new Maps.SortedMapDifferenceImpl(onlyOnLeft, onlyOnRight, onBoth, differences);
}

根据函数和set，构造一个Map

此类函数实际上就是伪造了一个Map，虽说实现了Map接口，但是底层的数据结构完全不是Map的Entry结构。只不过是保存了一个Set为Key值，并且记录了一个规则，当想要取数据的时候，通过规则计算后才可以获取到数据，判断只需要判断Set集合中的元素便可。

1.传入一个set和一个规则，返回一个Map

public static <K, V> Map<K, V> asMap(Set<K> set, Function<? super K, V> function) {
    return (Map)(set instanceof SortedSet?asMap((SortedSet)((SortedSet)set), function):new Maps.AsMapView(set, function));
}

2.传入一个SortedSet和一个规则，返回一个SortMap

public static <K, V> SortedMap<K, V> asMap(SortedSet<K> set, Function<? super K, V> function) {
    return Platform.mapsAsMapSortedSet(set, function);
}

3.传入一个NavigableSet和一个规则，返回一个NavigableMap

public static <K, V> NavigableMap<K, V> asMap(NavigableSet<K> set, Function<? super K, V> function) {
    return new Maps.NavigableAsMapView(set, function);
}

根据函数和迭代器，构造一个不可变的Map

此类方法传入的是一个容器的迭代器和一个规则，然后返回一个不可变的Map容器

1.传入一个key值容器和一个规则，直接交给重载函数去处理，返回一个不可变的Map容器

public static <K, V> ImmutableMap<K, V> toMap(Iterable<K> keys, Function<? super K, V> valueFunction) {
    return toMap((Iterator)keys.iterator(), valueFunction);
}

2.传入一个key值迭代器和一个规则返回一个不可变的map容器

public static <K, V> ImmutableMap<K, V> toMap(Iterator<K> keys, Function<? super K, V> valueFunction) {
    Preconditions.checkNotNull(valueFunction);
    LinkedHashMap builder = newLinkedHashMap();
    //使用迭代器中的值作为key值，使用规则计算出的值作为value值，存入builder中
    while(keys.hasNext()) {
        Object key = keys.next();
        builder.put(key, valueFunction.apply(key));
    }
    //返回一个不可变的容器
    return ImmutableMap.copyOf(builder);
}

3. 传入一个value值容器和一个规则，直接交给重载函数去处理，返回一个不可变的Map容器

public static <K, V> ImmutableMap<K, V> uniqueIndex(Iterable<V> values, Function<? super V, K> keyFunction) {
    return uniqueIndex((Iterator)values.iterator(), keyFunction);
}

4. 传入一个value值迭代器和一个规则返回一个不可变的map容器

public static <K, V> ImmutableMap<K, V> uniqueIndex(Iterator<V> values, Function<? super V, K> keyFunction) {
    Preconditions.checkNotNull(keyFunction);
    Builder builder = ImmutableMap.builder();
    //使用迭代器中的值作为value值，使用规则计算出的值作为key值，存入builder中
    while(values.hasNext()) {
        Object value = values.next();
        builder.put(keyFunction.apply(value), value);
    }
    //返回一个不可变的容器
    return builder.build();
}

从配置文件中读取数据，创建一个不可变的Map

1.从Properties获取的key和value，返回一个不可变的Map

public static ImmutableMap<String, String> fromProperties(Properties properties) {
    Builder builder = ImmutableMap.builder();
    Enumeration e = properties.propertyNames();
    //从properties获取的key和value，赋值到builder中
    while(e.hasMoreElements()) {
        String key = (String)e.nextElement();
        builder.put(key, properties.getProperty(key));
    }
    //返回一个不可变的Map
    return builder.build();
}

返回一个Entry或一个Entry集合

1.传入一个key和一个value，返回一个不可变的Entry

public static <K, V> Entry<K, V> immutableEntry(@Nullable K key, @Nullable V value) {
    return new ImmutableEntry(key, value);
}

返回一个特殊的BiMap类

1.传入一个BiMap返回一个线程安全的BiMap

guava中有一个Synchronized类，里面有很多guava中的集合的线程安全的类，详细可以看Synchronized类

public static <K, V> BiMap<K, V> synchronizedBiMap(BiMap<K, V> bimap) {
    return Synchronized.biMap(bimap, (Object)null);
}

2.传入一个BiMap返回一个unmodifiableBiMap

public static <K, V> BiMap<K, V> unmodifiableBiMap(BiMap<? extends K, ? extends V> bimap) {
    return new Maps.UnmodifiableBiMap(bimap, (BiMap)null);
}

根据一个Map和一个函数对Map进行转型

此类方法使用使用到了函数式编程，将一个Map的value作为新的Map的key，根据函数的规则计算出新的Map的Value，而这个转换只有在查看的时候才会做计算，而真正存储的是传入的map

1.传入一个Map和一个规则，返回一个有规则计算出来的Map

public static <K, V1, V2> Map<K, V2> transformValues(Map<K, V1> fromMap, Function<? super V1, V2> function) {
    return transformEntries((Map)fromMap, asEntryTransformer(function));
}

2.传入一个SortedMap和一个规则，返回一个由规则计算出来的新的Map

public static <K, V1, V2> SortedMap<K, V2> transformValues(SortedMap<K, V1> fromMap, Function<? super V1, V2> function) {
    return transformEntries((SortedMap)fromMap, asEntryTransformer(function));
}

3. 传入一个NavigableMap和一个规则，返回一个由规则计算出来的NavigableMap

public static <K, V1, V2> NavigableMap<K, V2> transformValues(NavigableMap<K, V1> fromMap, Function<? super V1, V2> function) {
    return transformEntries((NavigableMap)fromMap, asEntryTransformer(function));
}

4.传入一个Map和一个Maps规定的规则格式，根据规则返回一个新的Map

public static <K, V1, V2> Map<K, V2> transformEntries(Map<K, V1> fromMap, Maps.EntryTransformer<? super K, ? super V1, V2> transformer) {
    return (Map)(fromMap instanceof SortedMap?transformEntries((SortedMap)((SortedMap)fromMap), transformer):new Maps.TransformedEntriesMap(fromMap, transformer));
}

5.传入一个NavigableMap和一个Maps规定的规则格式，根据规则返回一个新的NavigableMap

public static <K, V1, V2> NavigableMap<K, V2> transformEntries(NavigableMap<K, V1> fromMap, Maps.EntryTransformer<? super K, ? super V1, V2> transformer) {
    return new Maps.TransformedEntriesNavigableMap(fromMap, transformer);
}

自己写一个函数进行过滤Map，然后返回一个同类型的Map

一、针对Key进行过滤

使用keyPredicate函数接口制定过滤规则，对Map进行过滤，对于Map中Key进行过滤的类FilteredKeyMap源码如下：

private static class FilteredKeyMap<K, V> extends Maps.AbstractFilteredMap<K, V> {
    Predicate<? super K> keyPredicate;
    FilteredKeyMap(Map<K, V> unfiltered, Predicate<? super K> keyPredicate, Predicate<? super Entry<K, V>> entryPredicate) {
        super(unfiltered, entryPredicate);
        this.keyPredicate = keyPredicate;
    }
    protected Set<Entry<K, V>> createEntrySet() {
        return Sets.filter(this.unfiltered.entrySet(), this.predicate);
    }

    Set<K> createKeySet() {
        return Sets.filter(this.unfiltered.keySet(), this.keyPredicate);
    }

    public boolean containsKey(Object key) {
        return this.unfiltered.containsKey(key) && this.keyPredicate.apply(key);
    }
}

可以看到他的方法中对KeySet进行了过滤处理，使用了Set中的filter方法

1.传入一个Map和过滤他的规则，返回一个新的Map

public static <K, V> Map<K, V> filterKeys(Map<K, V> unfiltered, Predicate<? super K> keyPredicate) {
    if(unfiltered instanceof SortedMap) {
        //如果这个Map属于SortedMap，则交给其他的重载方法进行处理
        return filterKeys((SortedMap)((SortedMap)unfiltered), keyPredicate);
    } else if(unfiltered instanceof BiMap) {
        //如果这个Map属于BiMap，则交给其他重载方法进行处理
        return filterKeys((BiMap)((BiMap)unfiltered), keyPredicate);
    } else {
        Preconditions.checkNotNull(keyPredicate);
        Predicate entryPredicate = keyPredicateOnEntries(keyPredicate);
        return (Map)(unfiltered instanceof Maps.AbstractFilteredMap?filterFiltered((Maps.AbstractFilteredMap)((Maps.AbstractFilteredMap)unfiltered), entryPredicate):new Maps.FilteredKeyMap((Map)Preconditions.checkNotNull(unfiltered), keyPredicate, entryPredicate));
    }
}

2.传入一个SortedMap，然后交给filterEntries方法进行处理

public static <K, V> SortedMap<K, V> filterKeys(SortedMap<K, V> unfiltered, Predicate<? super K> keyPredicate) {
    return filterEntries((SortedMap)unfiltered, keyPredicateOnEntries(keyPredicate));
}

3. 传入一个NavigableMap，然后交给filterEntries方法进行处理

public static <K, V> NavigableMap<K, V> filterKeys(NavigableMap<K, V> unfiltered, Predicate<? super K> keyPredicate) {
    return filterEntries((NavigableMap)unfiltered, keyPredicateOnEntries(keyPredicate));
}

4. 传入一个BiMap，然后交给filterEntries方法进行处理

public static <K, V> BiMap<K, V> filterKeys(BiMap<K, V> unfiltered, Predicate<? super K> keyPredicate) {
    Preconditions.checkNotNull(keyPredicate);
    return filterEntries((BiMap)unfiltered, keyPredicateOnEntries(keyPredicate));
}

Maps还提供了一些对Value、Entry、含有过滤器的Map进行过滤的方法。与上面过滤key的方法大体一样，都是继承了AbstractFilteredMap抽象类，实现了各自的过滤功能