Java中的小知识 ---- Map集合

1. Map集合和Collection集合一点关系都没有

2. Map集合以Key和Value这种键值对的方式存储元素，所有Map集合的Key特点：无序不可重复

3. Key和value都是存储Java对象的内存地址

4.所有Map集合的key特点：无序不可重复。Map集合中的key和set集合存储元素特点相同。

Map接口的实现类：
    HashMap：线程不安全，底层是哈希表数据结构
    Hashtable(用的很少)：线程安全，底层也是哈希表结构，所有方法都带有synchronized关键字。
        Hashtable有一个子类：Properties
            Properties是线程安全的因为继承了Hashtable，Properties存储元素的时候也是采用
            Key和Value的形式存储，并且Key和Value只支持String类型，不支持其他类型，Properties
            被称为属性类          

Map集合中的常用方法：

void clear();
    清空Map集合
boolean containsKey(Object key);
    判断Map集合中是否包含某个Key
boolean containsValue(Object value);
    判断Map中是否包含某个value
V get(object key);
    通过key获取value
boolean isEmpty();
    判断Map集合中的元素个数是否为0
V put(K key, V value);
   向Map集合中添加键值对 
V remove(Object key);
    通过key删除键值对
int size();
    获取Map集合中键值对的个数
Collection<V> values();
    获取集合中所有value，返回一个Collection
Set<K> keySet();
    获取Map集合中所有的key(所有的键是一个Set集合)

Set<Map.Entry<K,V>> entrySet();
    将Map集合转换成Set集合
比如：有一个map1集合对象(1 和 张三 是两个元素)
 key  value
  1    张三
  2    李四
 Set set = map1.entrySet();
就变成了一个set集合对象：
1=张三(1=张三  这是一个元素)
2=李四

部分方法代码

package com.wcc.test;

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

/**
 * Map部分方法演示
 * @Author kk
 * @Date 2020/3/24 20:49
 */
public class Demo1 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        //往map集合中放入元素
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        map.put(4,"赵六");
        //通过key获取value，输出王五
        System.out.println(map.get(3));
        //获取键值对的数量，输出4
        System.out.println("键值对的数量：" + map.size());
        //通过key删除键值对2
        map.remove(2);
        System.out.println("键值对的数量：" + map.size());
        //判断是否包含某个键
        System.out.println(map.containsKey(1));//true
        System.out.println(map.containsKey(7));//false
        //判断是否包含某个值
        System.out.println(map.containsValue("李四"));//false
        System.out.println(map.containsValue("张三"));//true
        //获取所有的value,输出[张三,王五,赵六]
        Collection<String> values = map.values();
        //增强for循环输出,输出张三  王五  赵六
        for (String value : values) {
            System.out.println(value);
        }
        System.out.println(values);
        //清空集合
        map.clear();
        System.out.println(map.isEmpty()); //true
    }
}

遍历Map集合

package com.wcc.test;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Map集合的遍历
 * @Author kk
 * @Date 2020/3/24 21:02
 */
public class Demo2 {
    public static void main(String[] args) {
        /*
            第一种方式：获取所有的key，通过遍历key来遍历value
         */
        Map<Integer,String> map = new HashMap();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        map.put(4,"赵六");
        map.put(5,"李七");
        map.put(6,"江八");
        map.put(7,"褚九");
        map.put(8,"刘十");
        //获取所有的Key存放到Set集合中
        Set<Integer> set = map.keySet();
        //遍历set集合
        for (Integer integer : set) {
            //通过键来遍历值
            System.out.println(integer +" = "+map.get(integer));
            /*
                1 = 张三
                2 = 李四
                3 = 王五
                4 = 赵六
                5 = 李七
                6 = 江八
                7 = 褚九
                8 = 刘十
             */
        }
    }
}

package com.wcc.test;

import java.awt.print.PrinterGraphics;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @Author kk
 * @Date 2020/3/24 21:12
 */
public class Demo3 {
    public static void main(String[] args) {
        /*
            第二种方式遍历Map集合：Set<Map.Entry<K,V>> entrySet();
            以上这个方法是把Map集合直接全部转换成Set集合
            Set集合中的元素类型是：Map.Entry
         */
        Map<Integer,String> map = new HashMap();

        map.put(11,"张三");
        map.put(12,"李四");
        map.put(13,"王五");
        map.put(14,"赵六");
        map.put(15,"李七");
        map.put(16,"江八");
        map.put(17,"褚九");
        map.put(18,"刘十");

        Set<Map.Entry<Integer, String>> set = map.entrySet();
        //用迭代器遍历set集合
        Iterator<Map.Entry<Integer, String>> iterator = set.iterator();
        while (iterator.hasNext()){
            Map.Entry<Integer, String> next = iterator.next();
            Integer key = next.getKey();
            String value = next.getValue();
            System.out.println(key + " = " + value);
        }
        System.out.println("----------------------------------------");
        //用增强for循环遍历
        for (Map.Entry<Integer, String> entry : set) {
            System.out.println(entry);
        }

    }
}

HashMap集合

/**
 * HashMap集合
 *      1.HashMap集合底层是一个哈希表/散列表的数据结构
 *      2.哈希表：
 *          是一个数组和单向链表的结合体
 *              数组：在查询方面效率很高，但是在随机增删方面效率很低
 *              单向链表：在随机增删方面效率很高，但是在查询方面效率很低
 *              而哈希表将以上两种数据结构融合在了一起，充分发挥各自的优点
 *      3.一个数组，数组中的每个元素都是Node(单向链表)，Node里有key，value，还有下一个节点的内存               地址 next
 *          HashMap底层实际上就是一个一维数组
 *              Node<K,V>[] table;
 *              而这个数组中的每个元素包含：
 *              static class Node<K,V>{
 *                  final int hash; //哈希值，key的hashCode()方法的执行结果
 *                  final K key; //存储到Map集合的key
 *                  V value; //存储到Mop集合的value
 *                  Node<K,V> next; //下一个节点的存储地址
 *              }
 *       4.map.put(k,v);
 *         v = map.get(k);
 *         这两个方法是如何执行的，必须掌握
*/