哈希表 - 详解

一，概念

Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的搜索方式有：
1. 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
2. 二分查找，时间复杂度为 ,但搜索前必须要求序列是有序的
上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如：
1. 根据姓名查询考试成绩
2. 不重复集合，即需要先搜索关键字是否已经在集合中
可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本节介绍的Map和Set是一种适合动态查找的集合容器。
 

二，模型

一般把搜索的数据称为关键字(Key)，和关键字对应的称为值（Value)，将其称之为Key-value的键值对，所以模型会有两种：
1. 纯 key 模型，比如：
        有一个英文词典，快速查找一个单词是否在词典中
        快速查找某个名字在不在通讯录中
2. Key-Value 模型，比如：
        统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>
而Map中存储的就是key-value的键值对，Set中只存储了Key。所以我们常常使用Map来解决一个集合当中存在几个要查找元素的问题，使用Set来解决一个集合当中是否存在要查找元素的问题。

三，Map

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

3.1 Map-Entry<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)	将Key对应的Value替换

注意：Map.Entry<K,V>并没有提供设置Key的方法
 

3.2 Map接口的常用方法

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

例如：

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

public class Test {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        //添加k-v
        map.put("this",3);
        map.put("super",2);
        //得到key的val值
        System.out.println(map.get("this"));
        //得到key的val值，若没有，返回defaultValue
        System.out.println(map.getOrDefault("sss",199));
        //是否包含key
        System.out.println(map.containsKey("this"));
        //删除k-v
        map.remove("this");
        //返回所有k-v映射关系
        Set<Map.Entry<String,Integer>> set = map.entrySet();
    }
}

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

四，Set

Set与Map主要的不同有两点：Set是继承自Collection的接口类，Set中只存储了Key。

4.1 set接口的常用方法

方法	解释
boolean add(E e)	添加元素，但重复元素不被添加成功
void clear()	清空集合
boolean contains(Object o)	判断是否在集合中
Iterator<E> iterator()	返回迭代器
boolean remove(Object o)	删除o
int size()	返回集合中的元素个数
boolean isEmpty()	判断是否为空
Object[] toArray()	转换成数组
boolean containsAll(Collection<?> c)	集合c中元素是否在set中全部存在
boolean addAll(Collection<? extends E> c)	将集合c中的元素添加到set中，可以去重

注意：

1. Set是继承自Collection的一个接口类
2. Set中只存储了key，并且要求key一定要唯一
3. TreeSet的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
4. Set最大的功能就是对集合中的元素进行去重
5. 实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在HashSet的基础上维护了一个双向链表来记录元素的插入次序。
6. Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入
7. TreeSet中不能插入null的key，HashSet可以
 

五，哈希表

哈希表是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希（散列）函数，存放记录的数组叫做哈希表（散列表）。

5.1 哈希冲突

对于两个数据元素的关键字x1和x2，有x1 != x2，但有：Hash(x1) == Hash(x2)，即：不同关键字通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞，举一个例子：

 5.2 如何尽量避免哈希冲突

 1. 设计一个合理的哈希函数：

• 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
• 哈希函数计算出来的地址能均匀分布在整个空间中
• 哈希函数应该比较简单
• 常见的哈希函数：直接定制法，除留余数法，平方取中法，折叠法，随机数法，数学分析法

2. 负载因子调节 ---- 负载因子 = 填入表中的元素个数 / 哈希表的长度

• 负载因子应该控制在 0.7~0.8左右，如果过大，就要扩容，增加哈希表的长度

5.3 如何解决哈希冲突

由于哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，那么我们应该如何解决哈希冲突呢？

1. 闭散列 - 又叫开放定地址法

当发生哈希冲突时，如果哈希表未被装满，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那么如何查找下一个空位置呢？我们有两种做法：

• 线性探测：将key存放到(key%array.length)+1位置处，如果该位置不为空，就放到下下个位置，但是要注意的是，如果我们将(key%array.length)所在的元素删除后，会影响对key的查找，因此线性探测采用标记的伪删除法来删除一个元素
• 二次探测：将key存放到(key+i^2)%array.length位置处，i = 1，2，3....，如果该位置不为空，i++

2. 开散列/哈希桶 - 又叫链地址法

该方法实际就是将哈希表变成一个 数组 + 链表 的结构，画个图理解一下：

 六，哈希桶的实现

public class HashBucket {
    private static class Node {
        private int key;
        private int value;
        Node next;
        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
    private Node[]  array;
    private int size;   // 当前的数据个数
    private static final double LOAD_FACTOR = 0.75;
    private static final int DEFAULT_SIZE = 10;//默认桶的大小
    public HashBucket() {
        array = new Node[DEFAULT_SIZE];
    }

    public boolean putFirst(int key, int value) {
        int index = key % array.length;//存放下标
        Node cur = array[index];//得到头节点
        while(cur != null){//查看表中是否含有key，如果有，则覆盖原有的映射关系
            if(cur.key == key){
                cur.value = value;
                return true;
            }
            cur = cur.next;
        }
        Node node = new Node(key,value);//新建节点
        node.next = array[index];//头插法
        array[index] = node;
        size++;
        if(loadFactor() > 0.75){
            resize();
        }
        return true;
    }

    /**
     * 扩容时要将所有的元素重新哈希！！！
     */
    private void resize() {
        Node[] tmpArr = new Node[array.length*2];
        for (int i = 0; i < array.length; i++) {
            Node cur = array[i];
            while(cur != null){
                Node curNext = cur.next;//记录cur.next
                int newIndex = cur.key % tmpArr.length;//找到新数组的下标
                cur.next = tmpArr[newIndex];//进行头插
                tmpArr[newIndex] = cur;
                cur = curNext;//cur向后移动
            }
        }
        array = tmpArr;//将新的数组赋给array
    }

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


    public int get(int key) {
        int index = key % array.length;
        Node cur = array[index];
        while(cur != null){
            if(cur.key == key){
                return cur.value;
            }
            cur = cur.next;
        }
        System.out.println("没有该值");
        return -1;
    }
}