数据结构之Map

一、Map的基本概念

Map是一个接口类,该类没有继承自Collection,该类中存储的是<K,V>结构的键值对,并且K一定是唯一的,不能重复.

二、<K,V>结构的键值对

Map.Entry<K, V> 是Map内部实现的用来存放<key, value>键值对映射关系的内部类，该内部类中主要提供了<key, value>的获取，value的设置以及Key的比较方式。

方法名	作用
K getKey()	返回entry中的key
V getValue()	返回entry中的value
V setValue(V value)	将键值对中的value替换为指定value

三、Map的常用方法

方法名	作用
V get(Object key)	返回 key 对应的 value
V getOrDefault(Object key, V defaultValue)	返回 key 对应的 value，key 不存在，返回默认值
V put(K key, V value)	设置 key 对应的 value
V remove(Object key)	删除 key 对应的映射关系
Set keySet()	返回所有 key 的不重复集合
Collection values()	返回所有 value 的可重复集合
Set<Map.Entry<K, V>> entrySet()	返回所有的 key-value 映射关系
boolean containsKey(Object key)	判断是否包含 key
boolean containsValue(Object value)	判断是否包含 value

注意:

1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap;
2. Map中存放键值对的Key是唯一的，value是可以重复的;
3. 在Map中插入键值对时，key不能为空，否则就会抛NullPointerException异常，但是value可以为空;
4. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复);
5. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复);
6. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。

四、TreeMap的使用案例

import java.util.TreeMap;
import java.util.Map;

public static void TestMap1(){
	Map<String, String> m = new TreeMap<>();
	
	// put(key, value):插入key-value的键值对
	// 如果key不存在，会将key-value的键值对插入到map中,返回null
	m.put("林冲", "豹子头");
	m.put("鲁智深", "花和尚");
	m.put("武松", "行者");
	m.put("宋江", "及时雨");
	String str = m.put("李逵", "黑旋风");
	System.out.println(m.size());
	System.out.println(m);
	
	// put(key,value): 注意key不能为空，但是value可以为空
	// key如果为空，会抛出空指针异常
	//m.put(null, "花名");
	str = m.put("无名", null);
	System.out.println(m.size());
	
	// put(key, value):
	// 如果key存在，会使用value替换原来key所对应的value，返回旧value
	str = m.put("李逵", "铁牛");
	
	// get(key): 返回key所对应的value
	// 如果key存在，返回key所对应的value
	// 如果key不存在，返回null
	System.out.println(m.get("鲁智深"));
	System.out.println(m.get("史进"));
	
	//GetOrDefault(): 如果key存在，返回与key所对应的value，如果key不存在，返回一个默认值
	System.out.println(m.getOrDefault("李逵", "铁牛"));
	System.out.println(m.getOrDefault("史进", "九纹龙"));
	System.out.println(m.size());
	
	//containKey(key)：检测key是否包含在Map中，时间复杂度：O(logN)
	// 按照红黑树的性质来进行查找
	// 找到返回true，否则返回false
	System.out.println(m.containsKey("林冲"));
	System.out.println(m.containsKey("史进"));
	
	// containValue(value): 检测value是否包含在Map中，时间复杂度: O(N)
	// 因为TreeMap是按照Key进行组织的，因此查找value时候就需要整体遍历
	// 找到返回true，否则返回false
	System.out.println(m.containsValue("豹子头"));
	System.out.println(m.containsValue("九纹龙"));
	
	// 打印所有的key
	// keySet是将map中的key防止在Set中返回的
	for(String s : m.keySet()){
		System.out.print(s + " ");
	}
	System.out.println();
	
	// 打印所有的value
	// values()是将map中的value放在collect的一个集合中返回的
	for(String s : m.values()){
		System.out.print(s + " ");
	}
	System.out.println();
	
	// 打印所有的键值对
	// entrySet(): 将Map中的键值对放在Set中返回了
	for(Map.Entry<String, String> entry : m.entrySet()){
		System.out.println(entry.getKey() + "--->" + 		entry.getValue());
	}
	System.out.println();
}

五、自定义实现HashMap

package java42_0328;

class HashNode {
    public int key;
    public int value;
    public HashNode next;

    public HashNode(int key, int value) {
        this.key = key;
        this.value = value;
    }
}

// 开散列/哈希桶的方式来处理哈希冲突~~
public class MyHashMap {
    private HashNode[] array = new HashNode[16];
    private int size = 0;

    public void put(int key, int value) {
        // 1. 先把 key 转成数组下标,
        //    简单粗暴的使用除留余数的方式来计算hash
        int index = key % array.length;
        // 2. 遍历该位置的链表, 看看 key 是不是已经存在了
        //    如果 key 已经存在, 就不必插入新的节点了, 直接修改 value 即可
        for (HashNode cur = array[index]; cur != null; cur = cur.next) {
            if (cur.key == key) {
                // 找到 key 存在了, 直接修改 value
                cur.value = value;
                return;
            }
        }
        // 3. 如果不存在相同的 key, 就插入新节点
        HashNode newNode = new HashNode(key, value);
        // 直接链表头插即可
        newNode.next = array[index];
        array[index] = newNode;
        size++;

        // 4. 判定 size 是否达到一定的数值. 如果达到数值, 就扩容
        // 负载因子达到多少才进行扩容?? 最好的办法是根据实际情况
        // 做实验试试~~
        // 负载因子越小, 此时空间利用率越低.
        // 负载因子越大, 此时性能就可能受到影响.
        // 此处老湿写的 0.75, java 标准库的 HashMap 负载因子阈值的默认值就是 0.75
        // 当时我们的 hash 表负载因子是 10
        if (loadFactor() > 0.75) {
            resize();
        }
    }

    private void resize() {
        // 创建一个更长的数组, 把原来的元素给拷贝进去
        HashNode[] newArray = new HashNode[array.length * 2];
        for (int i = 0; i < array.length; i++) {
            // 遍历当前链表
            HashNode next = null;
            for (HashNode cur = array[i]; cur != null; cur = next) {
                next = cur.next; // 修改 cur.next 之前, 先备份之前的位置
                // 把当前 cur 指向的节点插入到 新的数组 上
                int indexNew = cur.key % newArray.length;
                cur.next = newArray[indexNew];
                newArray[indexNew] = cur;
            }
        }
    }

    private double loadFactor() {
        return (double)size / array.length;
    }

    public Integer get(int key) {
        // 先根据 key, 计算得到一个 index
        // 再遍历链表即可
        int index = key % array.length;
        for (HashNode cur = array[index]; cur != null; cur = cur.next) {
            if (cur.key == key) {
                return cur.value;
            }
        }
        return null;
    }
}