Java数据结构——Set和Map

import java.util.TreeMap;
import java.util.Map;
public class Solution {
    public static void TestMap(){
        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);
        System.out.println(str);
        System.out.println("put()用法==============");
        //put(key,value):注意key不能为空，但是value可以为空
        //key如果为空，会抛出空指针异常
        //m.put(null,"花名")
        str = m.put("无名",null);
        System.out.println(str);
        System.out.println(m.size());

        //put(key,value);
        //如果key存在，会使用value替换原来key所对应的value，注意会返回旧的value
        str = m.put("李逵","铁牛");
        System.out.println(str);

        System.out.println("get用法 =======================");
        //get(key):返回key所对应的value
        //如果key存在，返回key所对应的value
        //如果key不存在，返回null
        System.out.println(m.get("鲁智深"));
        System.out.println(m.get("史进"));

        System.out.println("GetOrDefault()==============");
        System.out.println(":如果key存在，返回key所对应的value，如果key"+
                "不存在，返回一个默认值");
        System.out.println(m.getOrDefault("李逵","铁牛"));
        System.out.println(m.getOrDefault("史进","九纹龙"));
        System.out.println(m.size());

        System.out.println("containKey()===============");
        //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("九纹龙"));

        System.out.println("=====================");

        //打印所有的key
        //keySet是将map中的key防止在Set中返回
        for(String s:m.keySet()){
            System.out.println(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();
    }
    public static void main(String[] args) {
            TestMap();
    }
}

以上是TreeMap的应用。

2.5 HashMap的使用案例

java 复制代码

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

public class Solution {
    public static void TestMap() {
        Map<String, String> m = new HashMap<>();
        // 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);
        System.out.println(str);
        System.out.println("put()用法==============");
        // put(key,value): 注意key不能为空，但是value可以为空
        // key如果为空，会抛出空指针异常
        // m.put(null, "花名")
        str = m.put("无名", null);
        System.out.println(str);
        System.out.println(m.size());

        // put(key,value);
        // 如果key存在，会使用value替换原来key所对应的value，注意会返回旧的value
        str = m.put("李逵", "铁牛");
        System.out.println(str);

        System.out.println("get用法 =======================");
        // get(key): 返回key所对应的value
        // 如果key存在，返回key所对应的value
        // 如果key不存在，返回null
        System.out.println(m.get("鲁智深"));
        System.out.println(m.get("史进"));

        System.out.println("GetOrDefault()==============");
        System.out.println(": 如果key存在，返回key所对应的value，如果key" +
                "不存在，返回一个默认值");
        System.out.println(m.getOrDefault("李逵", "铁牛"));
        System.out.println(m.getOrDefault("史进", "九纹龙"));
        System.out.println(m.size());

        System.out.println("containKey()===============");
        // containKey（key）: 检测key是否包含在Map中，事件复杂度：O（1）
        // 按照哈希表的性质进行查找
        // 找到返回true，否则返回false
        System.out.println(m.containsKey("林冲"));
        System.out.println(m.containsKey("史进"));

        // containValue(value): 检测value是否包含在Map中，事件复杂度：O(N)
        // 因为HashMap是按照Key进行组织的，因此查找value的时候就需要整体遍历
        // 找到返回true，否则返回false
        System.out.println(m.containsValue("豹子头"));
        System.out.println(m.containsValue("九纹龙"));

        System.out.println("=====================");

        // 打印所有的key
        // keySet是将map中的key防止在Set中返回
        for (String s : m.keySet()) {
            System.out.println(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();
    }

    public static void main(String[] args) {
        TestMap();
    }
}

总结

HashMap 和 TreeMap 都是 Map 接口的实现，但它们在内部数据结构和性能特性上有所不同。
HashMap 基于哈希表，不保证映射的顺序（存储和遍历的顺序 ），++允许空键和空值++。
TreeMap 基于红黑树，保证映射的顺序，不允许空键（但允许空值）。

通过使用 HashMap，你可以实现相同的功能，但性能和行为可能会有所不同。

3.Set的说明

public interface Set<E> extends Collection<E>

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

3.1常见方法说明

注意：

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

3.2TreeSet的使用案例

java 复制代码

public class Solution {
    public static void TestSet(){
        Set<String> s = new TreeSet<>();
        //add(key):如果key不存在，则插入，返回true
        //如果key存在，返回false
        boolean isin = s.add("apple");
        System.out.println(isin);
        s.add("orange");
        s.add("peach");
        s.add("banana");
        System.out.println(s.size());
        System.out.println(s);
        isin = s.add("apple");
        //apple存在 add函数返回false
        System.out.println(isin);
        System.out.println("contains============");
        //contains(key):如果key存在，返回true，否则返回false
        System.out.println(s.contains("apple"));
        System.out.println(s.contains("watermelen"));
        System.out.println("remove===============");
        //remove(key):key存在，删除成功返回true
        //key不存在，删除失败返回false
        //key为空，抛出空指针异常
        s.remove("apple");
        System.out.println(s);
        s.remove("watermelen");
        System.out.println(s);
        //s.remove(null);//抛出空指针异常
        //返回迭代器
        System.out.println("Iterator==============");
        Iterator<String> it = s.iterator();
        while(it.hasNext()){
            System.out.println(it.next()+"");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        TestSet();
    }
}

3.3HashSet的使用案例

java 复制代码

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Solution {
    public static void TestSet() {
        Set<String> s = new HashSet<>();
        
        // add(key): 如果key不存在，则插入，返回true
        // 如果key存在，返回false
        boolean isin = s.add("apple");
        System.out.println(isin); // 输出 true，因为 "apple" 是第一个添加的
        s.add("orange");
        s.add("peach");
        s.add("banana");
        System.out.println(s.size()); // 输出 4
        System.out.println(s); // 输出的顺序可能每次不同，因为 HashSet 不保证顺序

        isin = s.add("apple");
        // "apple" 存在，add函数返回 false
        System.out.println(isin); // 输出 false

        System.out.println("contains============");
        // contains(key): 如果key存在，返回true，否则返回false
        System.out.println(s.contains("apple")); // 输出 true
        System.out.println(s.contains("watermelen")); // 输出 false

        System.out.println("remove===============");
        // remove(key): key存在，删除成功返回true
        // key不存在，删除失败返回false
        s.remove("apple");
        System.out.println(s); // "apple" 被移除

        s.remove("watermelen"); // 尝试移除不存在的元素，没有效果
        System.out.println(s);

        System.out.println("Iterator==============");
        // 返回迭代器
        Iterator<String> it = s.iterator();
        while (it.hasNext()) {
            System.out.println(it.next()); // 迭代输出，顺序不固定
        }
    }

    public static void main(String[] args) {
        TestSet();
    }
}

4.搜索树

4.1概念

二叉搜索树又称二叉排序树，它或者是一颗空树，或者是具有以下性质的二叉树：

若它的左子树不为空，则左子树所有节点的值都小于根节点的值。
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。
它的左右子树也分别为二叉搜索树。

eg.

4.2查找

4.3插入

1.如果树为空树，即根==null，直接插入

若为空树，直接插入，然后返回true

2.如果树不是空树，按照查找逻辑确定插入位置，插入新节点。

4.4操作-删除（难点）

设待删除结点为 cur, 待删除结点的双亲结点为 parent

1.cur.left==null

cur 是 root，则 ++root = cur.right。++

cur 不是 root，cur 是 parent.left，则 ++parent.left = cur.right 。++

cur 不是 root，cur 是 parent.right，则++parent.right = cur.right++

2.cur.right==null

cur 是 root，则 ++root = cur.left++

cur 不是 root，cur 是 parent.left，则 ++parent.left = cur.left++

cur 不是 root，cur 是 parent.right，则 ++parent.right = cur.left++

3. cur.left != null && cur.right != null

需要使用替换法进行删除，即在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题。

其中一个方法：

++要么在左树找到最大的数据（左树最右边的数据）跟cur替换。++
++要么在右树里面找到最小的数据（右树最左边的数据）跟cur替换。++

如图：

++删除20的这个节点++

4.5代码实现

java 复制代码

public class BinarySearchTree {
    public static class Node{
        int key;
        Node left;
        Node right;

        public Node(int key){
            this.key = key;
        }
    }
    private Node root = null;
    //在搜索树中查找key，如果找到，返回key所在的节点，否则返回null
    public Node search(int key){
        Node cur = root;
        while(cur!=null){
            if(key == cur.key){
                return cur;
            }else if(key<cur.key){
                cur = cur.left;
            }else{
                cur = cur.right;
            }
        }
        return null;
    }

    //插入
    public boolean insert(int key){
        fi(root == null){
            root = new Node(key);
            return true;
        }
        Node cur = root;
        Node parent = null;
        while(cur!=null){
            if(key == cur.key){
                return false;
            }else if(key<cur.key){
                parent = cur;
                cur = cur.left;
            }else{
                parent = cur;
                cur = cur.right;
            }
        }
        Node node = new Node(key);
        //parent遍历到父节点的位置，进行父节点的左右节点插入操作
        if(key< parent.key){
            parent.left = node;
        }else{
            parent.right = node;
        }
        return true;
    }

    //删除操作成功返回true，失败返回false
    public  boolean remove(int key){
        Node cur = root;
        Node parent = null;
        while(cur!=null){
            if(key == cur.key){
                break;
            }else if(key<cur.key){
                parent = cur;
                cur = cur.left;
            }else {
                parent =cur;
                cur = cur.right;
            }
        }
        if(null == cur){
            return false;
        }
        //根据cur的孩子是否存在分为四种请款
        //1.cur左右孩子均不存在；
        //2.cur只有左孩子
        //3.cur只有右孩子
        //4.cur左右孩子均存在

        //除了情况四之外，其他情况可以直接删除
        if(cur.left == null&&cur.right == null||cur.left == null){
            if (parent.left == cur){
                parent.left= cur.right;
            }else if(parent.right == cur){
                parent.right = cur.right;
            }
        }else if(cur.right == null){
            if (parent.left == cur){
                parent.left= cur.left;
            }else if(parent.right == cur){
                parent.right = cur.left;
            }
        }else {
            Node targetParent = cur;
            Node target = cur.right;
            while(target.left!=null){
                targetParent = target;
                target = target.left;
            }
            cur.key = target.key;
            //删除节点,两种情况
            if(targetParent.left == target){
                targetParent.left = target.right;
            }else{
                targetParent.right = target.right;
            }
        }
        return true;
    }

    public static void main(String[] args) {
            //.....................
    }
}

4.6性能分析

插入和删除操作都必须先查找，查找效率代表了二叉树中各个操作的性能。

对有n个节点的二叉树，若每个元素查找的概率相等，而二叉搜索树平均查找长度是节点在二叉搜索树的深度的函数，即节点越深，则比较的次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：

最差情况下，二叉搜索树退化为单支树，其平均比较次数为：

4.7和Java类集的关系

TreeMap 和 TreeSet 即 java 中利用搜索树实现的 Map 和 Set；实际上用的是红黑树，而红黑树是一棵近似平衡的二叉搜索树，即在二叉搜索树的基础之上 + 颜色以及红黑树性质验证，关于红黑树的内容后序再进行讲解。

5.哈希表

5.1概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找的时间复杂度为O（N），平衡树中为树的高度，即，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到搜索的元素，如果构造一种存储结构，通过某种函数使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素

根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。

搜索元素

对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。

该方式即为哈希（散列）方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表（Hash Table ）（或者称散列表）。

例如：数据集合{1,7,6,4,5,9}；

哈希函数设置为：hash（key）=key%capacity;capacity为存储元素底层空间的总大小。

该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。问题：按照上述哈希方式，向集合中插入元素44会出现什么问题？

5.2冲突-概念

对于两个数据元素的关键字和(i!=j),有！=，但有：Hash()==Hash(),,即：不同关键字通过相同哈希函数计算出相同的哈希地址，该现象称为哈希冲突或哈希碰撞。

把具有不同关键码而具有相同哈希地址的数据元素称为"同义词"。

5.3冲突-避免

首先，我们需要明确一点，由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做到的应该是尽量的降低冲突率。

5.4冲突-避免-哈希函数设计

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。哈希函数设计原则：

++哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间。++
++哈希函数计算出来的地址能均匀分布在整个空间中。++
++哈希函数应该比较简单。++

5.5哈希函数

在哈希表（Hash Table）的数据结构中，键值对的存储和检索通常依赖于哈希函数来计算哈希地址。这个过程是哈希表实现快速数据访问的关键。以下是详细的步骤和解释：

哈希函数的作用：

输入：哈希函数接收一个键（key）作为输入。
输出：它产生一个整数作为输出，这个输出称为哈希值或哈希码。
目的：这个哈希值用来确定键值对在哈希表数组中的存储位置。

常见哈希函数：

1.直接定制法--（常用）

取关键字的某个线性函数为散列地址：Hash(Key) = A*key+B 优点：简单、均匀缺点：需要事先知道关键字的分布情况。使用场景：适合查找比较小且连续的情况。

2.除留余数法--（常用）

设散列表中允许的地址数为m，取一个不大于m，但是最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key)=key%p(p<=m),将关键码转换成哈希地址。

3.平方取中法--（了解）

假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位（或710）作为哈希地址。平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况。

4.折叠法--（了解）

折叠法是将关键字从左到右分割成位数相等的几部分（最后一部分位数可以短些），然后将这几部分叠加求和，并将散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况。

5.随机数法--（了解）

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key)=random(key),其中random为随机数函数。

通常应用于关键字长度不等时采用此法。

6.数学分析法--（了解）

设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。

5.6冲突-避免-负载因子调节（重点掌握）

散列表的载荷因子定义为：=填入表中的元素个数 / 散列表的长度

是散列表装满程度的标志因子。由于表长是定值，与"填入表中的元素个数"成正比 ，所以，越大，表明填入表中的元素越多，产生的冲突的可能性就越大；反之，越小，表明填入表中的元素越少，产生冲突的可能性就越小。实际上，散列表的平均查找长度是载荷因子的函数，只是不同处理冲突的方法有不同的函数。

对于开放定址法，载荷因子是特别重要因素，应严格限制在0.7~0.8以下。超过0.8，查表时的CPU缓存不命中（cache missing）按照指数曲线上升。因此，一些采用开放定址法的hash库，如Java的系统库限制了载荷因子为0.75，超过此值将resize（调整大小）散列表。

负载因子和冲突率的关系粗略演示

所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。

已知哈希表中已有的关键个数是不可变的，那我们调整的就只有哈希表中的数组的大小。

5.7冲突-解决（两种）

解决哈希冲突 两种常见的方法是：闭散列 和开散列

5.8冲突-解决-闭散列

**闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被填满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的"下一个"空位置中去。**那如何寻找下一个空位置呢？

寻找下一个空位置方法：

线性探测

比如上面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，++但是该位置已经放了值为4的元素，即发生哈希冲突。++

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

插入：

通过哈希函数获取待插入元素在哈希表中的位置。
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素。（++比如图中的下标4中存放4,44本来也放下标四的但发生冲突了，就找到了下一个空的位置++）

采用闭散列处理哈希冲突时，++不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。++比如删除元素4，如果直接删除掉，44查找起来可能会受影响，因此线性探测采用标记的伪删除法来删除一个元素。

2. 二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找一下个空位置的方法为：%m,或者:%m。其中：i = 1,2,3....，是通过散列函数Hash(x)对元素关键码key进行计算得到的位置，m是表的大小。对于上面的如果要插入44，产生冲突，使用解决后的情况为：

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。

因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

5.9 冲突-解决-开散列/哈希桶（重点掌握）

开散列又叫链地址法（开链法），首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表连接起来，各链表的头结点存储在哈希表中。

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

++开散列，可以认为时候把一个在大集合中的搜索问题转化为在小集合中做搜索了。++

5.10冲突严重时的解决办法

刚才我们提到了，哈希桶其实可以看做将大集合的搜索问题转化为小集合的搜索问题了，那如果冲突严重,就意味着小集合的搜索性能其实也不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：

每个桶的背后是另一个哈希表。
每个桶的背后是一颗搜索树。

5.11 实现

java 复制代码

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[] arr;
    private int size;
    private static final double LOAD_FACTOR = 0.75;

    public int put(int key,int value){
        int index = key%arr.length;
        //在链表中查找key所在的结点
        //如果找到了，更新
        //所有结点都不是key，插入一个新的结点
        for(Node cur = arr[index];cur!=null;cur = cur.next){
            if(key == cur.key){
                int oldValue = cur.value;
                cur.value = value;
                return oldValue;
            }
        }
        Node node = new Node(key,value);
        node.next = arr[index];
        arr[index] = node;
        size++;

        if(loadFactor()>=LOAD_FACTOR){
            resize();
        }
        return -1;
    }

    //重新调整大小
    private void resize(){
        Node[] newArray = new Node[arr.length*2];
        for(int i=0;i<arr.length;i++){
            Node next;//方便记录下一个链表的节点
            for(Node cur = arr[i];cur!=null;cur = next){
                next = cur.next;//记录下一个节点
                int index = cur.key%newArray.length;//创建的新数组之后重新
//求出元素在新数组中的位置
                //下面的代码为链表头插法
                //当newArray处为空时，
//第一个插入新数组的节点的next域为newArray[index]的地址
                //当newArray处不为空时，
//cur指向的节点的next域就指向了newArray处的第一个节点，即cur要作为新头结点
                cur.next = newArray[index];
                //cur作为新节点
                newArray[index] = cur;
            }
        }
    }
    private double loadFactor(){
        return size*1.0/ arr.length;
    }

    //构造函数
    public  HashBucket(){
        arr = new Node[8];
        size = 0;
    }

    //在哈希表中找出元素
    public  int get(int key){
        int index = key%arr.length;
        Node head = arr[index];
        for(Node cur = head;cur!=null;cur = cur.next){
            if(key == cur.key){
                return cur.value;
            }
        }
        return -1;
    }


    public static void main(String[] args) {
        //...........
    }
}

5.12性能分析

虽然哈希表已知在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的，也就是每个桶中的链表的长度是一个常数，所以，通常意义一下，我们认为哈希表的插入/删除/查找时间复杂度是O(1)。

5.13和Java集类的关系

HashMap和HashSet即Java中是利用哈希表实现的Map和Set
Java中使用的是哈希桶方式解决冲突的。
Java会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）。
Java中计算哈希值实际上是调用的类的hashCode方法，进行key的相等性比较式调用key的equals方法。所以如果要用自定义类作为HashMap的key或者HashSet的值，必须要覆写hashCode和equals方法，而且要做到equals相等的对象，hashCode一定是一致的。

总结：

掌握搜索树背后的额原理和基本实现
掌握哈希表背后原理和基本实现，同时掌握解决哈希冲突的方法。