Map 实现类之一：HashMap

Map 实现类之一：HashMap
HashMap是 Map 接口 使用频率最高的实现类。
允许使用null键和null值，与HashSet一样，不保证映射的顺序。
所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：
equals()和hashCode()
所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类
要重写：equals()
一个key-value构成一个entry
所有的entry构成的集合是Set:无序的、不可重复的
HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，
hashCode 值也相等。
HashMap 判断两个 value 相等的标准是：两个 value 通过 equals() 方法返回 true。

 HashMap 源码中的重要常量

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
MAXIMUM_CAPACITY ： ： HashMap的最大支持容量，2^30
DEFAULT_LOAD_FACTOR ：HashMap的默认加载因子
TREEIFY_THRESHOLD ：Bucket中链表长度大于该默认值，转化为红黑树
UNTREEIFY_THRESHOLD ：Bucket中红黑树存储的Node小于该默认值，转化为链表
MIN_TREEIFY_CAPACITY ：桶中的Node被树化时最小的hash表容量。（当桶中Node的
数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行
resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4
倍。）
table ：存储元素的数组，总是2的n次幂
entrySet： ：存储具体元素的集
size ：HashMap中存储的键值对的数量
modCount ：HashMap扩容和结构改变的次数。
threshold ：扩容的临界值，=容量*填充因子
loadFactor： ：填充因子

HashMap 的存储： 结构：JDK 1.8 之前

 HashMap的内部存储结构其实是 数组和链表的结合。当实例化一个HashMap时，
系统会创建一个长度为Capacity的Entry数组，这个长度在哈希表中被称为容量
(Capacity)，在这个数组中可以存放元素的位置我们称之为“桶”(bucket)，每个
bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。
 每个bucket中存储一个元素，即一个Entry对象，但每一个Entry对象可以带一个引
用变量，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Entry链。
而且新添加的元素作为链表的head。
 添加元素的过程：
向HashMap中添加entry1(key，value)，需要首先计算entry1中key的哈希值(根据
key所在类的hashCode()计算得到)，此哈希值经过处理以后，得到在底层Entry[]数
组中要存储的位置i。如果位置i上没有元素，则entry1直接添加成功。如果位置i上
已经存在entry2(或还有链表存在的entry3，entry4)，则需要通过循环的方法，依次
比较entry1中key和其他的entry。如果彼此hash值不同，则直接添加成功。如果
hash值不同，继续比较二者是否equals。如果返回值为true，则使用entry1的value
去替换equals为true的entry的value。如果遍历一遍以后，发现所有的equals返回都
为false,则entry1仍可添加成功。entry1指向原有的entry元素。

HashMap 的扩容
当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的
长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，而在
HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算
其在新数组中的位置，并放进去，这就是resize。
那么HashMap 什么时候进行扩容呢 ？
当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数
size)*loadFactor 时 ， 就 会 进 行 数 组 扩 容 ， loadFactor 的 默 认 值
(DEFAULT_LOAD_FACTOR)为0.75，这是一个折中的取值。也就是说，默认情况
下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中元素个数
超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把
数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，
而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，
那么预设元素的个数能够有效的提高HashMap的性能。

HashMap 的存储： 结构：JDK 1.8

 HashMap的内部存储结构其实是 数组+ 链表+ 树 的结合。当实例化一个
HashMap时，会初始化initialCapacity和loadFactor，在put第一对映射关系
时，系统会创建一个长度为initialCapacity的Node数组，这个长度在哈希表
中被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为
“桶”(bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查
找bucket中的元素。
 每个bucket中存储一个元素，即一个Node对象，但每一个Node对象可以带
一个引用变量next，用于指向下一个元素，因此，在一个桶中，就有可能
生成一个Node链。也可能是一个一个TreeNode对象，每一个TreeNode对象
可以有两个叶子结点left和right，因此，在一个桶中，就有可能生成一个
TreeNode树。而新添加的元素作为链表的last，或树的叶子结点。

那么HashMap 什么时候进行扩容和树形化呢 ？
当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数
size)*loadFactor 时 ， 就 会 进 行 数 组 扩 容 ， loadFactor 的 默 认 值
(DEFAULT_LOAD_FACTOR)为0.75，这是一个折中的取值。也就是说，默认
情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中
元素个数超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）
的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元
素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知
HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
当HashMap中的其中一个链的对象个数如果达到了8个，此时如果capacity没有
达到64，那么HashMap会先扩容解决，如果已经达到了64，那么这个链会变成
树，结点类型由Node变成TreeNode类型。当然，如果当映射关系被移除后，
下次resize方法时判断树的结点个数低于6个，也会把树再转为链表。

代码测试学习：

@Test
    public void test1(){
        Map map = new HashMap();
//        map = new Hashtable();
        map.put(null,123);//Hashmap中的键值对可以为空

    }

无报错：

@Test
    public void test2(){
        Map map = new HashMap();
        map = new LinkedHashMap();
        map.put(123,"AA");
        map.put(345,"BB");
        map.put(12,"CC");

        System.out.println(map);
    }

/*
    添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
    */

@Test
    public void test3(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //修改
        map.put("AA",87);

        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);

        map.putAll(map1);

        System.out.println(map);

        //remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //clear()
        map.clear();//与map = null操作不同
        System.out.println(map.size());
        System.out.println(map);
    }

/*
 元素查询的操作：
 Object get(Object key)：获取指定key对应的value
 boolean containsKey(Object key)：是否包含指定的key
 boolean containsValue(Object value)：是否包含指定的value
 int size()：返回map中key-value对的个数
 boolean isEmpty()：判断当前map是否为空
 boolean equals(Object obj)：判断当前map和参数对象obj是否相等
     */
    @Test
    public void test4(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        // Object get(Object key)
        System.out.println(map.get(45));
        //containsKey(Object key)
        boolean isExist = map.containsKey("BB");
        System.out.println(isExist);

        isExist = map.containsValue(123);
        System.out.println(isExist);

        map.clear();

        System.out.println(map.isEmpty());

    }

/*
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
*/

 @Test
    public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        //遍历所有的key集：keySet()
        Set set = map.keySet();
            Iterator iterator = set.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
        }
        System.out.println();
        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj : values){
            System.out.println(obj);
        }
        System.out.println();
        //遍历所有的key-value
        //方式一：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
        System.out.println();
        //方式二：
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key + "=====" + value);

        }

    }