JAVA中的Map简单使用

Map的简述
Map中得每个元素属于键值对模式。 如果往map中添加元素时 需要添加key 和 value. 它也属于一个接口，该接口常见得实现类有: HashMap. Map中key有唯一性的特点，不能重复。
1.如何创建Map对象

		public class Test1 {
		    public static void main(String[] args) {
		        //创建一个默认初始大小，负载因子为 默认的 Map；
		        Map map = new HashMap();
		        //创建一个初始大小为 16 ，负载因子默认的容器
		        Map map1 = new HashMap(16);
		        //创建一个初始大小为 16 ，负载因子 0.7 的容器
		        Map map2 = new HashMap(16,0.7f);
		    }
}

2.Map中的添加操作

		map.put("name","张三");
        map.put(18,12);
        map.put("age",19);
        //因为 Map具有唯一不能重复的特性，所以后者会把前者覆盖
        map.put("name","李四");
        map1.put("name","王五");
        map1.put("age","20");
        //如果指定得key存在，则不放入map中，如果不存在则放入map中
        map.putIfAbsent("age",28) ;
        System.out.println(map);
        System.out.println(map);
        //将 map1 中的每一个元素都添加到 map中，如果其中 key值重复，会将前者覆盖
        map.putAll(map1);
        System.out.println(map);

3.Map中的删除操作

 		//根据 key 来删除元素
        map.remove(18);
        System.out.println(map);
        //清空整个容器
        map.clear();
        System.out.println(map);

4.Map的修改操作。

		//根据 key值来修改元素，但是我们可以直接使用添加功能将前者覆盖可以达到相同效果
        map.replace("name","刘德华");//替换元素
        System.out.println(map);

5.Map中的查询操作

		//判断Map中是否有指定的key
        boolean a = map.containsKey("name");
        System.out.println(a);
        //根据指定的key返回 相应的Value值
        Object b = map.get("name");
        System.out.println(b);
        //返回这个Map 中的所有 key
        Set s = map.keySet();
        System.out.println(s);

6.Map的遍历

		//返回这个Map 中的所有 key
        Set s = map.keySet();
        System.out.println(s);
        for(Object k:s){
            Object value= map.get(k);//
            System.out.println(k+"================>"+value);
        }

7.Map的底层原理

JDK1.8 HashMap原理
Hashmap得原理，存储元素使用得put(key,value)，根据key得hash计算出相应得哈希值，根据相应得算法求出该元素在数组中得位置， 如果求出得哈希值相同，则称为哈希冲突，会根据equals来判断元素是否一致，如果equals不同，则存入单向链表上， 如果哈希碰撞得个数超过8个，则把链表转换为红黑二叉树。

JDK1.7和JDK1.8 HashMap得区别。
JDK1.7使用得数据结构: 数组+链表 而且链表插入模式为头部插入（造成死循环）。
JDK1.8使用得数据结构: 数组+链表+红黑树 而且链表得插入模式为尾部插入。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            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))))
                 //如果key得hash值相同，判断key得equals是否相同，替换原来得元素
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 判断链表得长度是否超过8个
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 把链表转换为红黑树结构
                            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;
    }