HashMapStudy

import java.util.Collection;
import java.util.HashMap;

/**
 * Create by tate ON 2017/11/11.
 */
public class HashMapStudy {
    public static void main(String[] args) {
//        HashMap<String,Object> m=new HashMap<String,Object>();
//        m.put("a", "rrr1");
//        m.put("a", "rrr2");
//        m.put("a", "rrr3");
//        m.put("a", "rrr4");


//        m.put("b", "tt9");
//        m.put("c", "tt8");
//        m.put("d", "g7");
//        m.put("e", "d6");
//        m.put("f", "d4");
//        m.put("g", "d4");
//        m.put("h", "d3");
//        m.put("i", "d2");
//        m.put("j", "d1");
//        m.put("k", "1");
//        m.put("o", "2");
//        m.put("p", "3");
//        m.put("q", "4");
//        m.put("r", "5");
//        m.put("s", "6");
//        m.put("t", "7");
//        m.put("u", "8");
//        m.put("v", "9");
        //System.out.println(m.size());
        //System.out.println(m.get("a"));


        HashMap<String,Object> hashMap = new HashMap<String,Object>(3);
        hashMap.put("inital",3);
        hashMap.put("inita",5);
        System.out.println(hashMap.get("inital").toString());
        System.out.println(hashMap.entrySet());

        System.out.println(hashMap.size());
        System.out.println(hashMap.entrySet());
        System.out.println(hashMap.keySet());
        System.out.println(hashMap.values());
        //1.8独有
        hashMap.forEach((k,v)-> {
            if("inital".equals(k)){
                System.out.println(v);
            }}
        );

        // 基于hash表实现的，内部通过单链表解决冲突，容量不足会自动增长
        // 非线程安全的，只用于单线程环境下，再多线程的环境下，
        // 可以使用concurrent并发包下面的       concurrentHashMap：通过把整个Map分为N个Segment（类似HashTable），可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。
        // 初始容量是16，实际的容量必须是2的倍数
        // 加载因子0。75   计算阀值时候：容量*加载因子
        // 最大容量也是2的倍数 2^30次方，容量大于这个的时候会被这个覆盖，所以再大也就这么大了
        // entry是单向链表 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"
        // key和value 允许为null
        // 首先，如果key为null，则直接从哈希表的第一个位置table[0]对应的链表上查找。记住，
        //      key为null的键值对永远都放在以table[0]为头结点的链表中，
        //      当然不一定是存放在头结点table[0]中。
        // 扩容：调用了resize的方法，其实是新建了一个hashmap的数组，调用transfer的方法，
        // 新建一个HashMap，将“旧HashMap”的全部元素添加到“新HashMap”中，这种方式，非常的浪费耗时的
        // ，所以在使用的时候，最好能够预先估计好hashmap中元素的个数，有助于提高其性能

        //核心在于计算hash值和索引值的方法
        //   hash用的位的操作使hash值的计算效率很高
        //   return h & (length-1);  一般是hash值对length取模运算：除法散列，
        //      使得元素在哈希表中散列的比较的均匀，但是对用到除法，效率很低，但是这样的算法
        //      保证了效率夜保证了均匀，这是比较厉害的地方了，同时有一个地方，容量为什么是2的倍数，这样
        //      首先，length为2的整数次幂的话，h&(length-1)就相当于对length取模，这样便保证了散列的均匀，
        //      同时也提升了效率；其次，length为2的整数次幂的话，为偶数，
        //      这样length-1为奇数，奇数的最后一位是1，
        //      这样便保证了h&(length-1)的最后一位可能为0，也可能为1（这取决于h的值），
        //      即与后的结果可能为偶数，也可能为奇数，这样便可以保证散列的均匀性，
        //      而如果length为奇数的话，很明显length-1为偶数，
        //      它的最后一位是0，这样h&(length-1)的最后一位肯定为0，
        //      即只能为偶数，这样任何hash值都只会被散列到数组的偶数下标位置上，
        //      这便浪费了近一半的空间，因此，length取2的整数次幂，
        //      是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列。

        System.out.println(10 & 11);


//        // hashmap entrySet() 遍历    优先考虑 性能上entrySet()会优于keySet()   entrySet的key value都拿出来了，
//          keySet和名字一样，只拿了key，到时候要value的时候又要去拿一次，这样比较耗费资源。
//          当然，好处是，如果只要key的话，这样能减少资源的消耗，要的时候再拿
//        for(Map.Entry<Object,Object> m: hash.entrySet()){
//            System.out.println(m.getKey()+"---"+m.getValue());
//        }
//        //hashmap keySet() 遍历
//        for(Object m: hash.keySet()){
//            System.out.println(m+"---"+hash.get(m));
//        }
//        // treemap keySet()遍历
//        for(Object m: treeMap.keySet()){
//            System.out.println(m+"---"+treeMap.get(m));
//        }

        //遍历value 用values




    }