Map和Entry是什么？

Map是独立的接口，为所有

映射结构（Key-Value）的数据

提供了统一接口

Entry是Map的内部接口，用于存储键值

Map源码

以下按照空格分为：获取集合大小和判空、增-删-获取(默认获取)-查存在-清空、获取键集/值集/键值集、从Object继承的方法、replace方法、Java8新方法

public interface Map<K, V> {

	int size();
	boolean isEmpty();
	
	V put(K key, V value);
	void putAll(Map<? extends K, ? extends V> m);
	default V putIfAbsent(K key, V value) {
    	V v = get(key);
    	if (v == null) {
        	v = put(key, value);
    	}
    	return v;
	}
	
	V remove(Object key);
	default boolean remove(Object key, Object value) {
    	Object curValue = get(key);
    	if (!Objects.equals(curValue, value) || (curValue == null && !containsKey(key))) {
        	return false;
    	}
   	 	remove(key);
    	return true;
    }
	
	V get(Object key);
	default V getOrDefault(Object key, V defaultValue) {
   	 	V v;
    	return (((v = get(key)) != null) || containsKey(key)) ? v : defaultValue;
	}
	
	boolean containsKey(Object key);
	boolean containsValue(Object value);
	void clear();
	
	Set<K> keySet();
	Collection<V> values();
	Set<Map.Entry<K, V>> entrySet();
	
	boolean equals(Object o);
	int hashCode();
	
	default V replace(K key, V value) {
    	V curValue;
   		if (((curValue = get(key)) != null) || containsKey(key)) {
        	curValue = put(key, value);
    	}
    	return curValue;
    }
    default boolean replace(K key, V oldValue, V newValue) {
    	Object curValue = get(key);
    	if (!Objects.equals(curValue, oldValue) || (curValue == null && !containsKey(key))) {
        	return false;
    	}
   		put(key, newValue);
   		return true;
	}
	
	default void forEach(BiConsumer<? super K, ? super V> action) {
    	Objects.requireNonNull(action);
    	for (Map.Entry<K, V> entry : entrySet()) {
        	K k;
        	V v;
       		try {
            	k = entry.getKey();
            	v = entry.getValue();
        	} catch (IllegalStateException ise) {
            	throw new ConcurrentModificationException(ise);
        	}
        	action.accept(k, v);
   		}
	}
	default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
    	Objects.requireNonNull(function);
    	for (Map.Entry<K, V> entry : entrySet()) {
        	K k;
        	V v;
        	try {
           		k = entry.getKey();
            	v = entry.getValue();
        	} catch (IllegalStateException ise) {
            	throw new ConcurrentModificationException(ise);
        	}
        	v = function.apply(k, v);
       	 	try {
            	entry.setValue(v);
	        } catch (IllegalStateException ise) {
				throw new ConcurrentModificationException(ise);
        	}
    	}
    }
    
	default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
    	Objects.requireNonNull(mappingFunction);
    	V v;
    	if ((v = get(key)) == null) {
        	V newValue;
       		if ((newValue = mappingFunction.apply(key)) !
            	put(key, newValue);
            	return newValue;
       		}
    	}
    	return v;
	}
	default V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    	Objects.requireNonNull(remappingFunction);
    	V oldValue;
    	if ((oldValue = get(key)) != null) {
        	V newValue = remappingFunction.apply(key, oldValue);
       	 	if (newValue != null) {
            	put(key, newValue);
            	return newValue;
        	} else {
            	remove(key);
            	return null;
        	}
    	} else {
        	return null;
    	}
	}
	default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    	Objects.requireNonNull(remappingFunction);
    	V oldValue = get(key);
    	V newValue = remappingFunction.apply(key, oldValue);
    	if (newValue == null) {
        	if (oldValue != null || containsKey(key)) {
            	remove(key);
            	return null;
        	} else {
            	return null;
        	}
    	} else {
        	put(key, newValue);
        	return newValue;
    	}
	}
	
	default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
    	Objects.requireNonNull(remappingFunction);
    	Objects.requireNonNull(value);
    	V oldValue = get(key);
    	V newValue = (oldValue == null) ? value : remappingFunction.apply(oldValue, value);
    	if (newValue == null) {
        	remove(key);
    	} else {
        	put(key, newValue);
    	}
   	 	return newValue;
	}
}

为什么键集是Set，值集是Collectoion，键值集是Set？

在Map中，键是唯一的，不可重复的，故采用Set（其具有互异性），而值是可重复的，故采用Collectoion

键值集主要是key对value的映射，其也是唯一的，不可重复的

Entry源码

Entry是调用 Set<Map.Entry<K, V>>

entrySet() 所返回Set集合的泛型接口

，用于存储Key-Value，以下按照空格分为获取键值-设置值、从Object继承的方法、获取键值的Comparator

interface Entry<K, V> {

	K getKey();
	V getValue();
	V setValue(V value);
	
	boolean equals(Object o);
	int hashCode();
	
	public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K, V>> comparingByKey() {
   	 	return (Comparator<Map.Entry<K, V>> & Serializable)(c1, c2) -> c1.getKey().compareTo(c2.getKey());
	}
	public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K, V>> comparingByValue() {
   		return (Comparator<Map.Entry<K, V>> & Serializable)(c1, c2) -> c1.getValue().compareTo(c2.getValue());
	}
	public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
    	Objects.requireNonNull(cmp);
    	return (Comparator<Map.Entry<K, V>> & Serializable)(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
    }
    public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
    	Objects.requireNonNull(cmp);
    	return (Comparator<Map.Entry<K, V>> & Serializable)(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
	}
}