欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

数据结构之Map

程序员文章站 2024-02-20 19:14:34
...

一、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;
    }
}

相关标签: 数据结构