「面试必问」BTree、红黑树、哈希算法分析、哈希表源码解析

时间  2021-08-14
标签 java 面试 算法 数组 markdown app 函数 源码分析 post 性能 栏目 快乐工作 繁體版
原文   原文链接

前言：

应广大读者的须要，霈哥给你们带来新一期的干货啦！java

高频面试题：BTree、红黑树、哈希算法分析、哈希表源码分析

若对你和身边的朋友有帮助, 抓紧关注 IT霈哥 点赞! 点赞! 点赞! 评论！收藏! 分享给更多的朋友共同窗习交流, 天天持续掘金离不开你的点赞支持!

第一章 BTree、红黑树

1.1 BTree

  • 二叉树：binary tree ,是每一个结点不超过2的有序树（tree） 。

简单的理解，就是一种相似于咱们生活中树的结构，只不过每一个结点上都最多只能有两个子结点。面试

二叉树是每一个节点最多有两个子树的树结构。顶上的叫根结点，两边被称做“左子树”和“右子树”。算法

如图：数组

1.2 红黑树

咱们要说的是二叉树的一种比较有意思的叫作红黑树，红黑树自己就是一颗二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。markdown

如图:app

红黑树能够经过红色节点和黑色节点尽量的保证二叉树的平衡，从而来提升效率。函数

红黑树的约束:源码分析

  1. 节点能够是红色的或者黑色的。
  2. 根节点是黑色的。
  3. 叶子节点(特指空节点)是黑色的。
  4. 每一个红色节点的子节点都是黑色的。
  5. 任何一个节点到其每个叶子节点的全部路径上黑色节点数相同。

红黑树的特色:post

速度特别快,趋近平衡树。性能

第二章 哈希算法分析、哈希表源码分析

2.1 对象的哈希值

java.lang.Object类中定义了方法：public int hashCode()返回对象的哈希码值，任何类都继承Object，也都会拥有此方法。

定义Person类，不添加任何成员，直接调用Person对象的hashCode()方法，执行Object类的hashCode()：

public class Person{}
复制代码

测试类

public static void main(String[] args){
	Person person = new Person();
	int code = person.hashCode();
}
复制代码

看到运行结果，就是一个int类型的整数，若是将这个整数转为十六进制就看到所谓的对象地址值，可是他不是地址值，咱们将他称为对象的哈希值。

Person类重写hashCode()方法：直接返回0

public int hashCode(){
	return 0;
}
复制代码

运行后，方法将执行Person类的重写方法，结果为0，属于Person类自定义对象的哈希值，而没有使用父类Object类方法hashCode()。

2.2 String对象的哈希值

public static void main(String[] args){
    String s1 = new String("abc");
    String s2 = new String("abc");
    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
}
复制代码

程序分析：两个字符串对象都是采用new关键字建立的，s1==s2的结果为false，可是s1，s2两个对象的哈希值倒是相同的，均为96354，缘由是String类继承Object，重写了父类方法hashCode()创建本身的哈希值。

String类的hashCode方法源码分析

字符串底层实现是字符数组，被final修饰，一旦建立不能修改。

private final char value[];
复制代码

定义字符串“abc”或者是new String("abc")，都会转成char value[]数组存储，长度为3。

/* * String类重写方法hashCode() * 返回自定义的哈希值 */
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
    	char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
    	hash = h;
    }
    return h;
}
复制代码

String的哈希算法分析

  • int h = hash，hash是成员变量，默认值0，int h = 0。
  • 判断h==0为true && value.length>0，数组value的长度为3，保存三个字符abc，判断结果总体为true。
  • char val[] = value，将value数组赋值给val数组。
  • for循环3次，将value数组进行遍历，取出abc三个字符。
  • 第一次循环： h = 31 * h + val[0]，h = 31 * 0 + 97结果：h = 97。
  • 第二次循环： h = 31 * 97 + val[1]，h = 31 * 97 + 98结果：h = 3105。
  • 第三次循环： h = 31 * 3105 + val[2]，h = 31 * 3105 + 99结果：h = 96354。
  • return 96354。
  • 算法：31 * 上一次的哈希值+字符的ASCII码值，31属于质数，每次乘以31是为了下降字符串不一样，可是计算出相同哈希值的几率。

2.3 哈希表

什么是哈希表呢？

在JDK1.8以前，哈希表底层采用数组+链表实现，即便用数组处理冲突，同一hash值的链表都存储在一个数组里。可是当位于一个桶中的元素较多，即hash值相等的元素较多时，经过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减小了查找时间。

  • 哈希表的初始化容量，数组长度为16个
    • 当数组容量不够时，扩容为原数组长度的2倍
  • 加载因子为0.75
    • 指示当数组的容量被使用到长度的75%时，进行扩容。

简单的来讲，哈希表是由数组+链表+红黑树（JDK1.8增长了红黑树部分）实现的，以下图所示。

2.4 哈希表存储字符对象的过程图

总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于咱们来说保证HashSet集合元素的惟一，其实就是根据对象的hashCode和equals方法来决定的。若是咱们往集合中存放自定义的对象，那么保证其惟一，就必须复写hashCode和equals方法创建属于当前对象的比较方式。

2.5 哈希表源代码分析

HashSet集合自己并不提供功能，底层依赖HashMap集合，HashSet构造方法中建立了HashMap对象：

map = new HashMap<>();
复制代码

所以源代码分析是分析HashMap集合的源代码，HashSet集合中的add方法调研的是HashMap集合中的put方法。

HashMap无参数构造方法的分析

//HashMap中的静态成员变量
static final float DEFAULT_LOAD_FACTOR = 0.75f;
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
复制代码

解析：使用无参数构造方法建立HashMap对象，将加载因子设置为默认的加载因子，loadFactor=0.75F。

HashMap有参数构造方法分析

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
    	throw new IllegalArgumentException("Illegal initial capacity: " +
    initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
    	initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
    	throw new IllegalArgumentException("Illegal load factor: " +
    loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}
复制代码

解析带有参数构造方法，传递哈希表的初始化容量和加载因子

  • 若是initialCapacity（初始化容量）小于0，直接抛出异常。
  • 若是initialCapacity大于最大容器，initialCapacity直接等于最大容器
    • MAXIMUM_CAPACITY = 1 << 30 是最大容量 (1073741824)
  • 若是loadFactor（加载因子）小于等于0，直接抛出异常
  • tableSizeFor（initialCapacity）方法计算哈希表的初始化容量。
    • 注意：哈希表是进行计算得出的容量，而初始化容量不直接等于咱们传递的参数。

tableSizeFor方法分析

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
复制代码

解析该方法对咱们传递的初始化容量进行位移运算，位移的结果是 8 4 2 1 码

  • 例如传递2，结果仍是2，传递的是4，结果仍是4。
  • 例如传递3，结果是4，传递5，结果是8，传递20，结果是32。

Node 内部类分析

哈希表是采用数组+链表的实现方法，HashMap中的内部类Node很是重要

static class Node<K,V> implements Map.Entry<K,V> {
     final int hash;
     final K key;
     V value;
     Node<K,V> next;
 Node(int hash, K key, V value, Node<K,V> next) {
     this.hash = hash;
     this.key = key;
     this.value = value;
     this.next = next;
}
复制代码

解析内部类Node中具备4个成员变量

  • hash，对象的哈希值
  • key，做为键的对象
  • value，做为值得对象（讲解Set集合，不牵扯值得问题）
  • next，下一个节点对象

存储元素的put方法源码

public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}
复制代码

解析put方法中调研putVal方法，putVal方法中调用hash方法。

  • hash(key)方法：传递要存储的元素，获取对象的哈希值
  • putVal方法，传递对象哈希值和要存储的对象key

putVal方法源码

Node<K,V>[] tab; Node<K,V> p; int n, i;
	if ((tab = table) == null || (n = tab.length) == 0)
		n = (tab = resize()).length;
复制代码

解析方法中进行Node对象数组的判断，若是数组是null或者长度等于0，那么就会调研resize()方法进行数组的扩容。

resize方法的扩容计算

if (oldCap > 0) {
     if (oldCap >= MAXIMUM_CAPACITY) {
         threshold = Integer.MAX_VALUE;
         return oldTab;
     }
     else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
              oldCap >= DEFAULT_INITIAL_CAPACITY)
         newThr = oldThr << 1; // double threshold
}
复制代码

解析计算结果，新的数组容量=原始数组容量<<1，也就是乘以2。

肯定元素存储的索引

if ((p = tab[i = (n - 1) & hash]) == null)
	 tab[i] = newNode(hash, key, value, null);
复制代码

解析：i = (数组长度 - 1) & 对象的哈希值，会获得一个索引，而后在此索引下tab[i]，建立链表对象。

不一样哈希值的对象，也是有可能存储在同一个数组索引下。

遇到重复哈希值的对象

Node<K,V> e; K k;
 if (p.hash == hash &&
 	((k = p.key) == key || (key != null && key.equals(k))))
		 e = p;
复制代码

解析若是对象的哈希值相同，对象的equals方法返回true，判断为一个对象，进行覆盖操做。

else {
     for (int binCount = 0; ; ++binCount) {
     	if ((e = p.next) == null) {
     		p.next = newNode(hash, key, value, null);
     	if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
     		treeifyBin(tab, hash);
     	break;
 }
复制代码

解析若是对象哈希值相同，可是对象的equals方法返回false，将对此链表进行遍历，当链表没有下一个节点的时候，建立下一个节点存储对象。

后续连载文章, 敬请观看：

观看更多精品文章，请移步至 大厂必用技术汇总篇！🔥

若对你和身边的朋友有帮助, 抓紧关注 IT霈哥 点赞! 点赞! 点赞! 评论！收藏! 分享给更多的朋友共同窗习交流, 天天持续更新离不开你的支持!

欢迎关注个人B站，未来会发布文章同步视频~~~

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程