- 地图，和实际地点有映射关系
- 内置对象Entry，包含两个元素
- 单项一对一的关系
- 大词典，可以根据相应的键来找到值
- 方法
- Object put(Oject key,Object value)//增
- Object remove(Object key)//删
- void putAll(Map t)
- void clear()
- Ojbect get(Object key) //查词典
- boolean containsKey(Object value)
- Set getSet();//键值包装为set传出
- Collection values()
- set entrySet()//键值对包装成set对象传出，类型为Entry
- 实现子类
- HashMap
- 哈希算法实现，和treeSet有相似之出
- 使用哈希算法来计算地址偏移量，偏移到具体的地址，若无数据，则添加，若有数据，则构建红黑树，若当数据达到数组的3/4的时候进行扩容，所有map里的元素重新排列分布，当内存充裕的时候可极大提高效率
- 结构类似于，哈希表加链表或treeMap
- Hashtalbe 较老的的版本，效率较低
- Properties 类，管理配置文件
- 属性key和value都是string
- 一般用于配置文件
- getProperties(key)
- 哈希算法实现，和treeSet有相似之出
- TreeMap
- 键值实现自然排序，所有前提是key必须是可比对象。（和treeset不同的是treeset可以通过传入的自定义比较器，来让对象可比，treemap不具此特性）
- LinkedMap
- 效率低，不常使用
- HashMap
- 遍历方式
- foreach, foreach内置遍历机制可以遍历collection。
- Set getSet(); //map把key包装成set，通过foreach遍历
- Set entrySet(); //map把键值对包装成entry(内置类),通过foreache遍历
- Iterator, 集合实现类Iterator接口，可以通过生成迭代器来遍历
- 同上
- 比较，
- foreach代码更简洁，从1.5开始foreach出现，是比较新的遍历器，但底层是用迭代器实现
- Iterator一开始的map唯一遍历方式，更安全，更可靠，但是代码略臃肿
- foreach, foreach内置遍历机制可以遍历collection。
HashSet原理
- 底层调用HashMap(),只取其key值。
HashMap原理
- 575，进入
- new初始化
- 缺省，初始化负载因子，控制数组使用率
- put(k,v) :添加一个元素
- 计算要插入的值在当前数组下的哈希地址
- 当前数组是否需要扩容，
- 扩容则储存的值全部重排
- 拿到哈希地址，查看当前是链表还是红黑树结构
- 判断添加元素后是否需要升级为红黑树结构
- 链表，进行遍历插入，中间需要去重
- 红黑树，插入之后调整，中间依旧需要去重
-
常量
- Treeify_threshold : 变红黑树的上线，如果大于
- Untreeify_threshold : 把红黑树变成链表的界限值
- final float loadFactor : 负载因子，无参构造为3/4
- Default_initial_capacity : 缺省的数组初始容量
-
变量
- size 容量
- modCount 修改次数的计数器
- threshold 当前对象中的哈希表的使用上线，扩容界限
-
数组
- Node[]
- 维护的哈希表或链表
- java8,改成node，前面为Entry
-
Node<K,V> implements Map.Entry<k,v> //Node类
- hash
- key
- value
- next
//HashMap部分源码浅观，这里主要为整理思路，查看红黑树，hash求解策略的，请移步百度。
//主要源码，格式经过调整，拆解，例如，声明未换行，调用使用多层嵌套等等
//静态常量，参数部分：
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 缺省的数组的初始容量:16
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 3/4 缺省的负载因子, 控制数组的使用率
static final int TREEIFY_THRESHOLD = 8; // 变红黑树的上限, 如果链表中的元素个数大于等于此值, 把链表变成红黑树
static final int UNTREEIFY_THRESHOLD = 6; // 把红黑树再还原成链表的界限值
transient Node<K,V>[] table; // 它是最核心最重要的哈希表, 是一个Node数组
static class Node<K,V> implements Map.Entry<K,V> { // 内部类Node表示Entry, Java8以前这个类就叫Entry
final int hash; // Entry对象的哈希值, 应该就是键对象的hashCode()方法的值
final K key; // 这是键对象
V value; // 这是值对象
Node<K,V> next; // 用于构建链表的指针
Node(int hash, K key, V value, Node<K,V> next) {// 第1个参数是哈希值, 第2个键, 第3个是值, 第4个是下一个节点对象的地址
}
}
transient int size; // 计数器
transient int modCount; // 修改次数控制
int threshold; // 临界值；当前对象中的哈希表的使用上限 = 数组容量 * 负载因子
final float loadFactor; // Map的负载因子值, 如果使用无参构造器创建Map,它的值就是3/4, 作用是控制数组的使用率，超出扩容
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true); //包装方法，依此为，hash值，key, value, 真，假
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) { //添加元素，
Node<K,V>[] tab; // 数组引用
Node<K,V> p; // 某个结点, 某个数组元素, 保存的是本次要插入数组的下标处的元素
int n; // 保存数组的长度
int i; // 保存当前要插入的键的下标值
if ((tab = table) == null || (n = tab.length) == 0) { // 判读是否为首次添加元素
tab = resize(); //调整长度
n = tab.length; //调整后长度为n
}
//接下两行源码集合于第三行，这里拆开分析
i = (n - 1) & hash; //15 & 5 , 效果相当于 hash % n , 只有当对2^n-1取余的时候可以有此效果，验证。。。。有效
p = tab[i]; // 取数组中下标为i的元素
if (p == null) { // i位置为空, 原来没有插入过元素
tab[i] = newNode(hash, key, value, null); // 创建新节点对象, 并保存在数组中
}
else { // 出现了下标冲突
Node<K,V> e;
K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) // 用于去重, 去重的标准两个对象equals为true,或者哈希码相等并且key相等
e = p; // 重复则覆盖
else if (p instanceof TreeNode) //Node如果已经构建红黑树，在树上添加
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else { //Node在链表上，把新结点链接到已有结点上
for (int binCount = 0; ; ++binCount) { // 遍历链表, 找到尾结点
if ((e = p.next) == null) { // p此时就是尾结点
p.next = newNode(hash, key, value, null); // 把新结点插入到尾结点之后
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st // 判断链表元素个数如果大于等于8就把此链表变成红黑树
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) //去重
break;
p = e;
}
}
if (e != null) { // existing mapping for key, 键重复时, 替换值
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold) // 调整计数器, 如果容量大于上限, 调用扩容函数
resize();
afterNodeInsertion(evict);
return null;
}
// 用于调整数组的大小
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // 获取老表
int oldCap = (oldTab == null) ? 0 : oldTab.length; // 老容量 : 16
int oldThr = threshold; // 老上限 : 12
int newCap, newThr = 0; // 新容量, 新上限
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) // 新容量是老容量的2倍
newThr = oldThr << 1; // double threshold // 新上限也是老上限的2倍
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // 第一次添加元素时执行
newCap = DEFAULT_INITIAL_CAPACITY; // 新容量是16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 新上限是12
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; // 刷新上限
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 创建数组对象，改变容量
table = newTab; // 刷新散列表
if (oldTab != null) { // 把旧的数据刷新到新的散列容器中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { // 节点不为空
oldTab[j] = null;
if (e.next == null) // 节点只有头，赋值到新表完事
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) // 节点是个树，调用函数进行赋值
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 节点是个链表，操作比较简单，直接操作
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
