Map接口的实现类

1.简述

　　Map没有继承Collection接口，Map提供key到value的映射（唯一，无序）。可以保存null，但是只有一个，第二个key，是空的时候会覆盖第一个key的value（也就是key不能重复，value可以），能够实现根据key快速查找value。Map支持泛型，形式如：Map<K,V>。

 　　Map接口中有以下几个常用实现类：

• HashMap：无序、线程不安全。
• TreeMap：有序（根据键排序，可自定义Comparator）、线程不安全。
• HashTable：无序、线程安全（锁全表）、不允许为null，性能较差。
• ConcurrentHashMap(一般用于多线程情况下)：无序、线程安全（锁一个桶），性能较好。
• LinkedHashMap：有序、线程不安全，根据插入顺序、访问遍历的HashMap。

2.HashMap

　　HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

　　需要注意的是：因为HashMap不是同步的，如果多个线程同时访问一个HashMap，而其中至少一个线程从结构上（指添加或者删除一个或多个映射关系的任何操作）修改了，则必须保持外部同步，以防止对映射进行意外的非同步访问。

　　定义一个HashMap的方式有如下几种：

//创建一个HashMap集合，默认初始容量为16，默认负载因子为0.75
Map<String, String> map = new HashMap<String, String>();
//创建一个HashMap集合，设置初始容量，默认负载因子为0.75
map = new HashMap<String, String>(30);
//创建一个HashMap集合，设置初始容量和负载因子
map = new HashMap<String, String>(30, 0.8f);

　　HashMap有很多常用方法，put、putAll、get、keySet、remove、size、isEmpty等，关于其他方法可以查看API。

　　常用方法说明如下：

//将指定的值与此映射中的指定键相关联
V put(K key, V value);
//将指定地图的所有映射复制到此地图
void putAll(Map<? extends K,? extends V> m);
//如果指定的键尚未与某个值相关联（或映射到 null ），则将其与给定值相关联并返回 null ，否则返回当前值
V putIfAbsent(K key, V value);
//返回到指定键所映射的值，或 null如果此映射包含该键的映射
V get(Object key);
//返回此地图中包含的键的Set视图
Set<K> keySet();
//返回此地图中包含的映射的Set视图
Set<Map.Entry<K,V>> entrySet();
//返回此地图中包含的值的Collection视图
Collection<V> values();
//对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常
void forEach(BiConsumer<? super K,? super V> action);
//返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射
V getOrDefault(Object key, V defaultValue);
//如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联
V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction);
//如果此映射包含指定键的映射，则返回 true
boolean containsKey(Object key);
//如果此地图将一个或多个键映射到指定值，则返回 true
boolean containsValue(Object value);
//如果此地图不包含键值映射，则返回 true
boolean isEmpty();
//返回此地图中键值映射的数量
int size();
//尝试计算用于指定键和其当前映射的值的映射（或 null如果没有当前映射）
V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction);
//如果指定的键尚未与值相关联（或映射到 null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 null
V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction);
//如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射
V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction);
//只有当目标映射到某个值时，才能替换指定键的条目
V replace(K key, V value);
//仅当当前映射到指定的值时，才能替换指定键的条目
boolean replace(K key, V oldValue, V newValue);
//将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常
void replaceAll(BiFunction<? super K,? super V,? extends V> function);
//返回此HashMap实例的浅拷贝：键和值本身不被克隆
Object clone();
//从该地图中删除指定键的映射（如果存在）
V remove(Object key);
//仅当指定的密钥当前映射到指定的值时删除该条目
boolean remove(Object key, Object value);
//从这张地图中删除所有的映射
void clear();

3.TreeMap

　　TreeMap基于红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的Comparator 进行排序，具体取决于使用的构造方法。

　　定义一个TreeMap的方式有如下几种：

//创建一个HashMap集合，按照key的自然顺序排列
Map<String, String> map = new TreeMap<String, String>();
//创建一个HashMap集合，传递Comparator具体实现，按照该实现规则进行排序
map = new TreeMap<String, String>(new Comparator<String>() {
    public int compare(String o1, String o2) {
        return 0;
    }
});
//传递一个map实体构建TreeMap集合,按照默认规则排序
map = new TreeMap<String, String>(new HashMap<String,String>());
//传递一个map实体构建TreeMap,按照传递的map的排序规则进行排序
map = new TreeMap<String, String>(new TreeMap<String,String>());

　　TreeMap有很多常用方法，put、putAll、get、keySet、remove、size、isEmpty等，关于其他方法可以查看API。

　　常用方法说明如下：

//将指定的值与此映射中的指定键相关联
V put(K key, V value);
//将指定地图的所有映射复制到此地图
void putAll(Map<? extends K,? extends V> map);
//返回到指定键所映射的值，或 null如果此映射包含该键的映射
V get(Object key);
//返回此地图中包含的键的Set视图
Set<K> keySet();
//返回此集合中包含的映射的Set视图
Set<Map.Entry<K,V>> entrySet();
//返回此集合中包含的值的Collection视图
Collection<V> values();
//返回与该集合中的最小键相关联的键值映射，如果集合为空，则返回 null
Map.Entry<K,V> firstEntry();
//返回此集合中当前的第一个（最低）键
K firstKey();
//返回与小于或等于给定键的最大键相关联的键值映射，如果没有此键，则 null
Map.Entry<K,V> floorEntry(K key);
//返回小于或等于给定键的最大键，如果没有这样的键，则返回 null
K floorKey(K key);
//只有当目标映射到某个值时，才能替换指定键的条目
V replace(K key, V value);
//仅当当前映射到指定的值时，才能替换指定键的条目
boolean replace(K key, V oldValue, V newValue);
//将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常
void replaceAll(BiFunction<? super K,? super V,? extends V> function);
//对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常
void forEach(BiConsumer<? super K,? super V> action);
//返回此集合中包含键的相反顺序NavigableSet
NavigableSet<K> descendingKeySet();
//返回此映射中包含的映射的反向排序视图
NavigableMap<K,V> descendingMap();
//返回与大于或等于给定键的最小键相关联的键值映射，如果没有此键，则 null 
Map.Entry<K,V> ceilingEntry(K key);
//返回大于或等于给定键的 null键，如果没有此键，则返回 null
K ceilingKey(K key);
//如果此映射包含指定键的映射，则返回 true
boolean containsKey(Object key);
//如果此集合中有一个或多个键映射到指定值，则返回 true 
boolean containsValue(Object value);
//返回此地图中键值映射的数量
int size();
//从集合中删除所有的映射
void clear();
//返回此TreeMap实例的浅拷贝
Object clone();
//返回用于订购此地图中的键的比较器，或null如果此地图使用其键的natural ordering
Comparator<? super K> comparator();
//返回与该地图中最大关键字关联的键值映射，如果地图为空，则返回 null
Map.Entry<K,V> lastEntry();
//返回当前在此地图中的最后（最高）键
K lastKey();
//返回与最大密钥相关联的密钥值映射严格小于给定密钥，如果没有这样的密钥，则 null
Map.Entry<K,V> lowerEntry(K key);
//返回严格小于给定键的最大键，如果没有这样的键，则返回 null
K lowerKey(K key);
//返回此地图中包含的键的NavigableSet视图
NavigableSet<K>    navigableKeySet();
//删除并返回与该地图中的最小键相关联的键值映射，如果地图为空，则返回 null
Map.Entry<K,V> pollFirstEntry();
//删除并返回与该地图中最大密钥相关联的键值映射，如果地图为空，则返回 null
Map.Entry<K,V> pollLastEntry();
//从此TreeMap中删除此键的映射（如果存在）
V remove(Object key);

4.HashTable

　　HashTable类和HashMap用法几乎一样，底层实现几乎一样，只不过HashTable的方法添加了synchronized关键字确保线程同步检查，效率较低。

　　定义一个HashTable的方式有如下几种：

//创建一个Hashtable集合，默认初始容量（11）和负载因子（0.75）
Map<String, String> map = new Hashtable<String, String>();
//创建一个Hashtable集合，具有指定的初始容量和默认负载因子（0.75）
map = new Hashtable<String, String>(12);
//创建一个Hashtable集合，具有指定的初始容量和指定的负载因子
map = new Hashtable<String, String>(12, 0.8f);
//构造一个包含指定 Map中的元素的新Hashtable。
map = new Hashtable<String, String>(new HashMap<String, String>());

　　HashTable有很多常用方法，put、putAll、get、keySet、remove、size、isEmpty等，关于其他方法可以查看API。

　　常用方法说明如下：

//清除此散列表，使其不包含键
void clear();
//创建这个散列表的浅拷贝
Object clone();
//尝试计算指定键的映射及其当前映射的值（如果没有当前映射， null ）
V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction);
//如果指定的键尚未与某个值相关联（或映射到 null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 null
V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction);
//如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射
V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction);
//测试一些键映射到这个哈希表中的指定值
boolean contains(Object value);
//测试指定的对象是否在此哈希表中的键
boolean containsKey(Object key);
//如果此哈希表将一个或多个键映射到此值，则返回true
boolean containsValue(Object value);
//返回此散列表中值的枚举
Enumeration<V> elements();
//返回此地图中包含的映射的Set视图
Set<Map.Entry<K,V>> entrySet();
//根据Map界面中的定义，将指定的对象与此Map进行比较以相等
boolean equals(Object o);
//对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常
void forEach(BiConsumer<? super K,? super V> action);
//返回到指定键所映射的值，或 null如果此映射包含该键的映射
V get(Object key);
//返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射
V getOrDefault(Object key, V defaultValue);
//按照Map界面中的定义返回此Map的哈希码值
int hashCode();
//测试这个哈希表是否将值映射到值
boolean isEmpty();
//返回此散列表中键的枚举
Enumeration<K> keys();
//返回此地图中包含的键的Set视图
Set<K> keySet();
//如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联
V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction);
//将指定的 key映射到此 key value中指定的value
V put(K key, V value);
//将所有从指定地图的映射复制到此散列表
void putAll(Map<? extends K,? extends V> t);
//如果指定的键尚未与值相关联（或映射到 null ）将其与给定值相关联并返回 null ，否则返回当前值
V putIfAbsent(K key, V value);
//增加这个散列表的内部重组能力，从而更有效地适应和访问其条目
protected void rehash();
//从此散列表中删除键（及其对应的值）
V remove(Object key);
//仅当指定的密钥当前映射到指定的值时删除该条目
boolean remove(Object key, Object value);
//只有当目标映射到某个值时，才能替换指定键的条目
V replace(K key, V value);
//仅当当前映射到指定的值时，才能替换指定键的条目
boolean replace(K key, V oldValue, V newValue);
//将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常
void replaceAll(BiFunction<? super K,? super V,? extends V> function);
//返回此哈希表中的键数
int size();
//以一组条目的形式返回此 Hashtable对象的字符串表示形式，其括在大括号中，并以ASCII字符“ ,  ”（逗号和空格）分隔
String toString();
//返回此地图中包含的值的Collection视图
Collection<V> values();

5.ConcurrentHashMap

　　并发编程实践中，ConcurrentHashMap是一个经常被使用的数据结构，相比于Hashtable以及Collections.synchronizedMap()，ConcurrentHashMap在线程安全的基础上提供了更好的写并发能力，但同时降低了对读一致性的要求。ConcurrentHashMap的设计与实现非常精巧，大量的利用了volatile，final，CAS等lock-free技术来减少锁竞争对于性能的影响。

　　定义一个ConcurrentHashMap的方式有如下几种：

//创建一个ConcurrentHashMap集合，默认的初始表大小（16）
Map<String, String> map = new ConcurrentHashMap<String, String>();
//创建一个ConcurrentHashMap集合，其初始表格大小适应指定数量的元素，而不需要动态调整大小
map = new ConcurrentHashMap<String, String>(30);
//创建一个ConcurrentHashMap集合，给定元素数量和初始表密度
map = new ConcurrentHashMap<String, String>(30, 0.8f);
//创建一个ConcurrentHashMap集合，给定元素数量，表密度，和同时更新线程
map = new ConcurrentHashMap<String, String>(30, 0.8f, 20);
//构造一个包含指定Map中的元素的新ConcurrentHashMap
map = new ConcurrentHashMap<String, String>(new HashMap<String,String>());

　　ConcurrentHashMap有很多常用方法，put、putAll、get、keySet、remove、size、isEmpty等，关于其他方法可以查看API。

　　常用方法说明如下：

//从这张地图中删除所有的映射
void clear();
//尝试计算用于指定键和其当前映射的值的映射（或 null如果没有当前映射）
V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction);
//如果指定的键尚未与值相关联，则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 null
V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction);
//如果存在指定键的值，则尝试计算给出键的新映射及其当前映射值
V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction);
//传统方法测试如果一些键映射到此表中的指定值
boolean contains(Object value);
//测试此表中的指定对象是否为键
boolean containsKey(Object key);
//如果此映射将一个或多个键映射到指定的值，则返回 true
boolean containsValue(Object value);
//返回此表中值的枚举
Enumeration<V> elements();
//返回此地图中包含的映射的Set视图
Set<Map.Entry<K,V>> entrySet();
//将指定的对象与此映射进行比较以获得相等性
boolean equals(Object o);
//对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常
void forEach(BiConsumer<? super K,? super V> action);
//对每个（键，值）执行给定的动作
void forEach(long parallelismThreshold, BiConsumer<? super K,? super V> action);
//对每个（key，value）的每个非空变换执行给定的动作
<U> void forEach(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> transformer, Consumer<? super U> action);
//对每个条目执行给定的操作
void forEachEntry(long parallelismThreshold, Consumer<? super Map.Entry<K,V>> action);
//对每个条目的每个非空变换执行给定的操作
<U> void forEachEntry(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> transformer, Consumer<? super U> action);
//对每个键执行给定的动作
void forEachKey(long parallelismThreshold, Consumer<? super K> action);
//对每个键的每个非空变换执行给定的动作
<U> void forEachKey(long parallelismThreshold, Function<? super K,? extends U> transformer, Consumer<? super U> action);
//对每个值执行给定的操作
void forEachValue(long parallelismThreshold, Consumer<? super V> action);
//对每个值的每个非空转换执行给定的动作
<U> void forEachValue(long parallelismThreshold, Function<? super V,? extends U> transformer, Consumer<? super U> action);
//返回到指定键所映射的值，或 null如果此映射包含该键的映射
V get(Object key);
//返回指定键映射到的值，如果此映射不包含该键的映射，则返回给定的默认值
V getOrDefault(Object key, V defaultValue);
//返回此Map的哈希代码值，即映射中每个键值对的总和，即key.hashCode() ^ value.hashCode()
int hashCode();
//如果此地图不包含键值映射，则返回 true
boolean isEmpty();
//返回此表中键的枚举
Enumeration<K> keys();
//返回此地图中包含的键的Set视图
ConcurrentHashMap.KeySetView<K,V> keySet();
//返回此地图中键的Set视图，使用给定的公用映射值进行任何添加（即Collection.add(E)和Collection.addAll(Collection) ）
ConcurrentHashMap.KeySetView<K,V> keySet(V mappedValue);
//返回映射数
long mappingCount();
//如果指定的键尚未与（非空）值相关联，则将其与给定值相关联
V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction);
//创建一个新的Set支持的ConcurrentHashMap从给定的类型到Boolean.TRUE
static <K> ConcurrentHashMap.KeySetView<K,Boolean>    newKeySet();
//创建一个新的Set支持的ConcurrentHashMap从给定的类型到Boolean.TRUE
static <K> ConcurrentHashMap.KeySetView<K,Boolean>    newKeySet(int initialCapacity);
//将指定的键映射到此表中的指定值
V put(K key, V value);
//将指定地图的所有映射复制到此映射
void putAll(Map<? extends K,? extends V> m);
//如果指定的键尚未与值相关联，请将其与给定值相关联
V putIfAbsent(K key, V value);
//返回使用给定的reducer将所有（key，value）对的给定变换累加到组合值的结果，如果没有则返回null
<U> U reduce(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer);
//返回使用给定的reducer累加所有条目的结果，以组合值，如果没有则返回null
Map.Entry<K,V> reduceEntries(long parallelismThreshold, BiFunction<Map.Entry<K,V>,Map.Entry<K,V>,? extends Map.Entry<K,V>> reducer);
//返回使用给定的reducer将所有条目的给定变换累加到组合值的结果，否则返回null
<U> U reduceEntries(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer);
//返回使用给定的reducer累加给定变换的结果，以组合值，给定基础作为一个标识值
double reduceEntriesToDouble(long parallelismThreshold, ToDoubleFunction<Map.Entry<K,V>> transformer, double basis, DoubleBinaryOperator reducer);
//返回使用给定的reducer累加给定变换的结果，以组合值，给定基础作为一个标识值
int reduceEntriesToInt(long parallelismThreshold, ToIntFunction<Map.Entry<K,V>> transformer, int basis, IntBinaryOperator reducer);
//返回使用给定的reducer累加给定变换的结果，以组合值，给定基础作为一个标识值
long reduceEntriesToLong(long parallelismThreshold, ToLongFunction<Map.Entry<K,V>> transformer, long basis, LongBinaryOperator reducer);
//返回使用给定的reducer累加所有键的结果，以组合值，如果没有则返回null
K reduceKeys(long parallelismThreshold, BiFunction<? super K,? super K,? extends K> reducer);
//返回使用给定的reducer累加所有键的给定变换以组合值的结果，如果没有则返回null
<U> U reduceKeys(long parallelismThreshold, Function<? super K,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer);
//返回使用给定的reducer累加所有键的给定变换的结果，以组合值，给定基础作为标识值
double reduceKeysToDouble(long parallelismThreshold, ToDoubleFunction<? super K> transformer, double basis, DoubleBinaryOperator reducer);
//返回使用给定的reducer累加所有键的给定变换的结果，以组合值，给定基础作为标识值
int reduceKeysToInt(long parallelismThreshold, ToIntFunction<? super K> transformer, int basis, IntBinaryOperator reducer);
//返回使用给定的reducer累加所有键的给定变换的结果，以组合值，给定基础作为标识值
long reduceKeysToLong(long parallelismThreshold, ToLongFunction<? super K> transformer, long basis, LongBinaryOperator reducer);
//返回使用给定的reducer将所有（key，value）对的给定变换累加到结合值的结果，给定的基数作为一个标识值
double reduceToDouble(long parallelismThreshold, ToDoubleBiFunction<? super K,? super V> transformer, double basis, DoubleBinaryOperator reducer);
//返回使用给定的reducer将所有（key，value）对的给定变换累加到结合值的结果，给定的基数作为一个标识值
int reduceToInt(long parallelismThreshold, ToIntBiFunction<? super K,? super V> transformer, int basis, IntBinaryOperator reducer);
//返回使用给定的reducer将所有（key，value）对的给定变换累加到结合值的结果，给定的基数作为一个标识值
long reduceToLong(long parallelismThreshold, ToLongBiFunction<? super K,? super V> transformer, long basis, LongBinaryOperator reducer);
//返回使用给定的reducer累加所有值的结果，以组合值，如果没有则返回null
V reduceValues(long parallelismThreshold, BiFunction<? super V,? super V,? extends V> reducer);
//返回使用给定的reducer累加所有值的给定变换以组合值的结果，否则返回null
<U> U reduceValues(long parallelismThreshold, Function<? super V,? extends U> transformer, BiFunction<? super U,? super U,? extends U> reducer);
//返回使用给定的reducer累加所有值的给定变换的结果，以组合值，给定基础作为标识值
double reduceValuesToDouble(long parallelismThreshold, ToDoubleFunction<? super V> transformer, double basis, DoubleBinaryOperator reducer);
//返回使用给定的reducer累加所有值的给定变换的结果，以组合值，给定基础作为标识值
int    reduceValuesToInt(long parallelismThreshold, ToIntFunction<? super V> transformer, int basis, IntBinaryOperator reducer);
//返回使用给定的reducer累加所有值的给定变换的结果，以组合值，给定基础作为标识值
long reduceValuesToLong(long parallelismThreshold, ToLongFunction<? super V> transformer, long basis, LongBinaryOperator reducer);
//从该地图中删除键（及其对应的值）
V remove(Object key);
//仅当当前映射到给定值时才删除密钥的条目
boolean remove(Object key, Object value);
//仅当当前映射到某个值时才替换该项的条目
V replace(K key, V value);
//仅当当前映射到给定值时才替换密钥的条目
boolean replace(K key, V oldValue, V newValue);
//将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常
void replaceAll(BiFunction<? super K,? super V,? extends V> function);
//通过在每个（键，值）上应用给定的搜索函数返回非空结果，如果没有则返回null
<U> U search(long parallelismThreshold, BiFunction<? super K,? super V,? extends U> searchFunction);
//返回一个非空结果，从每个条目应用给定的搜索函数，如果没有，则返回null
<U> U searchEntries(long parallelismThreshold, Function<Map.Entry<K,V>,? extends U> searchFunction);
//返回一个非空结果，在每个键上应用给定的搜索功能，如果没有，返回null
<U> U searchKeys(long parallelismThreshold, Function<? super K,? extends U> searchFunction);
//返回一个非空结果，对每个值应用给定的搜索函数，如果没有，返回null
<U> U searchValues(long parallelismThreshold, Function<? super V,? extends U> searchFunction);
//返回此地图中键值映射的数量
int size();
//返回此地图的字符串表示形式
String toString();
//返回此地图中包含的值的Collection视图
Collection<V> values();

6.LinkedHashMap

　　LinkedHashMap是带链表的HashMap，所以LinkedHashMap是有序，LinkedHashMap作为HashMap的扩展，它改变了HashMap无序的特征。它使用了一个双向的链表来会维护key-value对的次序，该链表维护了map的迭代顺序，该迭代顺序和key-value对的插入顺序保持一致。

　　定义一个LinkedHashMap的方式有如下几种：

//创建一个LinkedHashMap集合，默认的初始化容量（16）和负载因子（0.75）
Map<String, String> map = new LinkedHashMap<String, String>();
//创建一个LinkedHashMap集合，指定初始容量
map = new LinkedHashMap<String, String>(30);
//创建一个LinkedHashMap集合，指定初始容量和负载因子
map = new LinkedHashMap<String, String>(30, 0.8f);
//创建一个LinkedHashMap集合，指定初始容量、负载因子和订购模式
map = new LinkedHashMap<String, String>(30, 0.8f, true);
//构造一个包含指定Map中的元素的新LinkedHashMap。
map = new LinkedHashMap<String, String>(new HashMap<String, String>());

　　LinkedHashMap有很多常用方法，put、putAll、get、keySet、remove、size、isEmpty等，关于其他方法可以查看API。

　　常用方法说明如下：

//从这张地图中删除所有的映射
void clear();
//如果该地图将一个或多个键映射到指定的值，则返回 true
boolean containsValue(Object value);
//返回此地图中包含的映射的Set视图
Set<Map.Entry<K,V>> entrySet();
//对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常
void forEach(BiConsumer<? super K,? super V> action);
//返回到指定键所映射的值，或 null如果此映射包含该键的映射
V get(Object key);
//返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射
V getOrDefault(Object key, V defaultValue);
//返回此地图中包含的键的Set视图
Set<K> keySet();
//如果此地图应删除其最老的条目，则返回 true
protected boolean removeEldestEntry(Map.Entry<K,V> eldest);
//将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常
void replaceAll(BiFunction<? super K,? super V,? extends V> function);
//返回此地图中包含的值的Collection视图
Collection<V> values();