标签：Map Java HashMap 容量 16 元素 阈值
最近发现map集合不简单啊，整理一下子（虽然都是百度找，但这不是重点，重点是需要重新过一遍Map集合）。
关系图
虚线箭头表示实现，实线箭头表示继承
图中可以看到，所有Map的实现类都继承Map接口，其中抽象类AbstractMap是Map接口的一部分实现，而Map的所有实现类都继承了AbsctractMap这个抽象类
Map
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值
删除该Map对象中所有键值对；
void clear();
查询Map中是否包含指定的key值；
boolean containsKey(Object key);
查询Map中是否包含一个或多个value;
boolean containsValue(Object value);
返回map中包含的键值对所组成的Set集合，每个集合都是Map.Entry对象。
Set entrySet();
返回指定key对应的value，如果不包含key则返回null；
Object get();
查询该Map是否为空；
boolean isEmpty();
返回Map中所有key组成的集合；
Set keySet();
返回该Map里所有value组成的Collection。
Collection values();
添加一个键值对，如果集合中的key重复，则覆盖原来的键值对；
Object put(Object key,Object value);
将Map中的键值对复制到本Map中；
void putAll(Map m);
删除指定的key对应的键值对，并返回被删除键值对的value，如果不存在，则返回null；
Object remove(Object key);
删除指定键值对，删除成功返回true；
boolean remove(Object key,Object value);
返回该Map里的键值对个数；
int size();
Map中包括一个内部类Entry，该类封装一个键值对，常用方法：
返回该Entry里包含的key值;
Object getKey();
返回该Entry里包含的value值;
Object getvalue();
设置该Entry里包含的value值，并设置新的value值;
Object setValue(V value);
HashMap
1、使用 HashMap定义的 Map集合是无序存放的。
2、如果发现重复的 key会将新的数据替换掉已有的数据。
3、使用 HashMap子类保存数据时，key或 value可以保存为null。
4、HashMap是非线程安全的，只是用于单线程环境下，多线程环境下可以采用concurrent并发包下的concurrentHashMap。
HashMap原理
在数据量小的(JDK8后阈值为8)时候，HashMap是按照链表的模式存储的；当数据量变大之后，为了进行快速查找，会将这个链表变为红黑树(均衡二叉树)来进行保存，用hash来进行查找。
HashMap的几个概念：
容量：大于初始容量参数的最小2次幂，默认为16；
负载因子：HashMap扩容条件的一个参数，默认为0.75f;
阈值：容量与负载因子的乘积；
当元素个数为0时：
当初始容量有值时，初始阈值等于最大容量；
当初始容量没有值时，初始阈值为0，容量为为16；
当元素个数不为0时：
阈值均满足容量与负载因子的乘积。
测试源码
public static void main(String[] args) throws Exception {
//指定初始容量15来创建一个HashMap
HashMap m = new HashMap(0);
//获取HashMap整个类
Class<?> mapType = m.getClass();
//获取指定属性，也可以调用getDeclaredFields()方法获取属性数组
Field threshold = mapType.getDeclaredField("threshold");
//将目标属性设置为可以访问
threshold.setAccessible(true);
//获取指定方法，因为HashMap没有容量这个属性，但是capacity方法会返回容量值
Method capacity = mapType.getDeclaredMethod("capacity");
//设置目标方法为可访问
capacity.setAccessible(true);
//打印刚初始化的HashMap的容量、阈值和元素数量
System.out.println("初始容量："+capacity.invoke(m)+"初始阈值："+threshold.get(m)+" 元素数量："+m.size());
for (int i = 0; i < 17; i++) {
m.put(i, i);
//动态监测HashMap的容量、阈值和元素数量
System.out.println("容量："+capacity.invoke(m)+" 阈值："+threshold.get(m)+" 元素数量："+m.size());
}
}
1、创建一个初始容量为0的HashMap的容量、阈值情况以及put新元素之后的容量、阈值情况
new HashMap(0);
初始容量：1 初始阈值：1 元素数量：0
容量：2 阈值：1 元素数量：1
容量：4 阈值：3 元素数量：2
容量：4 阈值：3 元素数量：3
容量：8 阈值：6 元素数量：4
容量：8 阈值：6 元素数量：5
容量：8 阈值：6 元素数量：6
容量：16 阈值：12 元素数量：7
容量：16 阈值：12 元素数量：8
容量：16 阈值：12 元素数量：9
容量：16 阈值：12 元素数量：10
容量：16 阈值：12 元素数量：11
容量：16 阈值：12 元素数量：12
容量：32 阈值：24 元素数量：13
2、创建一个初始容量为3的HashMap的容量、阈值情况以及put新元素之后的容量、阈值情况
new HashMap(3);
初始容量：4 初始阈值：4 元素数量：0
容量：4 阈值：3 元素数量：1
容量：4 阈值：3 元素数量：2
容量：4 阈值：3 元素数量：3
容量：8 阈值：6 元素数量：4
容量：8 阈值：6 元素数量：5
容量：8 阈值：6 元素数量：6
容量：16 阈值：12 元素数量：7
容量：16 阈值：12 元素数量：8
容量：16 阈值：12 元素数量：9
容量：16 阈值：12 元素数量：10
容量：16 阈值：12 元素数量：11
容量：16 阈值：12 元素数量：12
容量：32 阈值：24 元素数量：13
容量：32 阈值：24 元素数量：14
容量：32 阈值：24 元素数量：15
2、创建一个默认初始容量的HashMap的容量、阈值情况以及put新元素之后的容量、阈值情况
new HashMap();
初始容量：16 初始阈值：0 元素数量：0
容量：16 阈值：12 元素数量：1
容量：16 阈值：12 元素数量：2
容量：16 阈值：12 元素数量：3
容量：16 阈值：12 元素数量：4
容量：16 阈值：12 元素数量：5
容量：16 阈值：12 元素数量：6
容量：16 阈值：12 元素数量：7
容量：16 阈值：12 元素数量：8
容量：16 阈值：12 元素数量：9
容量：16 阈值：12 元素数量：10
容量：16 阈值：12 元素数量：11
容量：16 阈值：12 元素数量：12
容量：32 阈值：24 元素数量：13
容量：32 阈值：24 元素数量：14
Hashtable
HashTable的操作几乎和HashMap一致，主要的区别在于HashTable为了实现多线程安全，在几乎所有的方法上都加上了synchronized锁，而加锁的结果就是HashTable操作的效率十分低下，现在基本已被淘汰，单线程转为使用HashMap，多线程使用ConcurrentHashMap。
HashTable与HashMap对比
（1）HashTable基于Dictionary类，HashMap是基于AbstractMap
（2）线程安全：HashMap是线程不安全的类，多线程下会造成并发冲突，但单线程下运行效率较高；HashTable是线程安全的类，很多方法都是用synchronized修饰，但同时因为加锁导致并发效率低下，单线程环境效率也十分低；
（3）插入null：HashMap允许有一个键为null，允许多个值为null；但HashTable不允许键或值为null；
（4）容量：HashMap底层数组长度必须为2的幂，这样做是为了hash准备，默认为16；而HashTable底层数组长度可以为任意值，这就造成了hash算法散射不均匀，容易造成hash冲突，默认为11；
WeakHashMap（说实话，没用过！！！）
WeakHashMap 继承于AbstractMap，实现了Map接口。
1、和HashMap一样，WeakHashMap 也是一个散列表，它存储的内容也是键值对(key-value)映射，而且键和值都可以是null。
2、WeakHashMap的键是“弱键”。在 WeakHashMap 中，当某个键不再正常使用时，会被从WeakHashMap中被自动移除。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为可终止的，被终止，然后被回收。某个键被终止时，它对应的键值对也就从映射中有效地移除。
这个“弱键”的原理：
大致上通过WeakReference和ReferenceQueue实现的。 WeakHashMap的key是“弱键”，即是WeakReference类型的；ReferenceQueue是一个队列，它会保存被GC回收的“弱键”。
实现步骤如下：
(1) 新建WeakHashMap，将“键值对”添加到WeakHashMap中。
实际上，WeakHashMap是通过数组table保存Entry(键值对)；每一个Entry实际上是一个单向链表，即Entry是键值对链表。
(2) 当某“弱键”不再被其它对象引用，并被GC回收时。在GC回收该“弱键”时，这个“弱键”也同时会被添加到ReferenceQueue(queue)队列中。
(3) 当下一次我们需要操作WeakHashMap时，会先同步table和queue。table中保存了全部的键值对，而queue中保存被GC回收的键值对；同步它们，就是删除table中被GC回收的键值对。
测试源码
public static void main(String[] args) {
Map<Thread, String> weakHashMap = new WeakHashMap<Thread, String>();
Thread thread1 = new Thread();
Thread thread2 = new Thread();
weakHashMap.put(thread1, "thread1");
weakHashMap.put(thread2, "thread2");
thread1 = null;
System.gc();
for(Entry<Thread, String> entry:weakHashMap.entrySet()){
System.out.println(entry.getValue());
}
Map<Thread, String> hashMap = new HashMap<Thread, String>();
Thread thread3 = new Thread();
Thread thread4 = new Thread();
hashMap.put(thread3, "thread3");
hashMap.put(thread4, "thread4");
thread3 = null;
System.gc();
for(Entry<Thread, String> entry:hashMap.entrySet()){
System.out.println(entry.getValue());
}
}
这里我主动的用垃圾回收进行了处理，得出的结果是：
thread2
thread4
thread3
可以看出WeakHashMap中的thread1被垃圾回收了。但是HashMap的thread3却没有回收。弱引用关系当垃圾回收发生的时候，如果键为null那么就会被回收。
EnumMap（说实话，也没用过！！！）
EnumMap是专门为枚举类型量身定做的Map实现。虽然使用其它的Map实现（如HashMap）也能完成枚举类型实例到值得映射，但是使用EnumMap会更加高效：它只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以EnumMap使用数组来存放与枚举类型对应的值。这使得EnumMap的效率非常高。EnumMap在内部使用枚举类型的ordinal()得到当前实例的声明次序，并使用这个次序维护枚举类型实例对应值在数组的位置。
1、Map接口的实现，其key-value映射中的key是Enum类型；
2、其原理就是一个对象数组，数组的下标索引就是根据Map中的key直接获取，即枚举中的ordinal值；
3、效率比HashMap高，可以直接获取数组下标索引并访问到元素；
4、EnumMap的key不允许为null，value可以为null，按照key在enum中的顺序进行保存，非线程安全。
测试源码
//创建枚举类
public enum Color{
RED,BLUE,BLACK,YELLOW,GREEN;
}
public static void main(String[] args) {
EnumMap<Color,String> map = new EnumMap<>(Color.class);
EnumMap<Color,String> map = new EnumMap<>(Color.class);
map.put(Color.YELLOW, "黄色");
map.put(Color.RED, "红色");
map.put(Color.BLUE, null);
// map.put(null, "无"); //会报NullPonitException的错误
map.put(Color.BLACK, "黑色");
map.put(Color.GREEN, "绿色");
for(Map.Entry<Color,String> entry:map.entrySet())
{
System.out.println(entry.getKey()+":"+entry.getValue());
}
System.out.println(map);
}
运行结果：
RED:红色
BLUE:null
BLACK:黑色
YELLOW:黄色
GREEN:绿色
{RED=红色, BLUE=null, BLACK=黑色, YELLOW=黄色, GREEN=绿色}
转载于：https://www.ycblog.top/article?articleId=132&pageNum=1
标签：Map,Java,HashMap,容量,16,元素,阈值 来源： https://blog.csdn.net/qq_41916305/article/details/118527055
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。