map

• 地图，和实际地点有映射关系
• 内置对象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)
  • TreeMap
    • 键值实现自然排序，所有前提是key必须是可比对象。（和treeset不同的是treeset可以通过传入的自定义比较器，来让对象可比，treemap不具此特性）
  • LinkedMap
    • 效率低，不常使用
• 遍历方式
  • foreach, foreach内置遍历机制可以遍历collection。
    • Set getSet(); //map把key包装成set，通过foreach遍历
    • Set entrySet(); //map把键值对包装成entry(内置类),通过foreache遍历
  • Iterator, 集合实现类Iterator接口，可以通过生成迭代器来遍历
    • 同上
  • 比较，
    • foreach代码更简洁，从1.5开始foreach出现，是比较新的遍历器，但底层是用迭代器实现
    • Iterator一开始的map唯一遍历方式，更安全，更可靠，但是代码略臃肿

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;
}