《每日问题》

阿里巴巴待招录工程师

已于 2023-03-13 00:41:47 修改

阅读量87

点赞数

文章标签：链表 java 数据结构 Powered by 金山文档

于 2023-03-09 21:55:27 首次发布

本文链接：https://blog.csdn.net/PHaoLin/article/details/129432248

版权

HashMap的存储特点是键无序、唯一，值可重复，通过键的hashCode计算存储位置。在JDK1.8后，底层实现为数组+链表+红黑树。哈希碰撞是指不同关键字得到相同哈希地址的情况，解决方法包括开放定址法和链地址法（拉链法）。并发问题处理通常需要考虑线程安全，例如使用线程安全的容器或同步机制。

摘要由CSDN通过智能技术生成

每日问题：

0309

Map存储特点？

map是关联键值对关系的集合；

Key(键) : 是无序的,去重的,唯一的；

Value(值): 是无序的.可重复的；

键值可是为任意引用数据类型；

一个key对应一个value. 如果对一个key进行了多次put,后面的将覆盖前面的；

HashMap的底层存储方式？

jdk1.8之前底层实现是数组加链表；

jdk1.8之后HashMap 的底层实现是数组+链表+红黑树的形式的，同时它的数组的默认初始容量是 16、扩容因子为 0.75，每次采用 2 倍的扩容。也就是说，每当我们数组中的存储容量达到 75%的时候，就需要对数组容量进行 2 倍的扩容。

过程：

**1.**调用put方法添加键值对key,value数据

**2.**根据key计算hash值

int hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

**3.**调用putVal(hash,key,value)实现存储键值对数据

**4.**执行putVal方法,第一步就判断哈希表底层的节点数组是否null,或者底层数组的长度0,如果是证明这是第一次添加,底层没有数组或者没有带有容量的数组,先调用resize()方法实现创建新数组

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

**5.**根据key的hash值计算位桶索引int index = (n - 1) & hash,判断table[index]==null是否存在单向链表的首节点

if ((p = tab[i = (n - 1) & hash]) == null)

**6.**如果=null,证明不存在单向链表,直接创建新节点,存储这一次要添加的键值对数据,直接放在数组table[index]作为单向链表的首节点

tab[i] = newNode(hash, key, value, null); --> new Node<>(hash, key, value, next)

**7.**如果!=null,证明存在单向链表的首节点,遍历这个链表,判断链表中每一个节点的存储的key与这一次要添加的键值对的key比较是否相等,

if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))

如果相同value覆盖

V oldValue = e.value;
e.value = value;
return oldValue;

如果不相同创建新节点,挂在原单向链表的最后

p.next = newNode(hash, key, value, null);

**8.**如果以上的步骤中执行到了new Node()创建新节点放入哈希表中,数据个数+1,判断是否>扩容阈值threshold,如果满足,就调用resize方法实现扩容

if (++size > threshold)

resize();

什么是hash碰撞？

在计算hash地址的过程中会出现对于不同的关键字出现相同的哈希地址的情况，即key1 ≠ key2，但是f(key1) = f(key2)，这种情况就是Hash 冲突。具有相同关键字的key1和key2称之为同义词。

通过优化哈希函数可以减少这种冲突的情况（如：均衡哈希函数），但是在通用条件下，考虑到于表格的长度有限及关键值（数据）的无限，这种冲突是不可避免的，所以就需要处理冲突。

如何解决hash碰撞？

解决哈希冲突的方法

解决哈希冲突的方法一般有：开放定址法、链地址法（拉链法）、再哈希法、建立公共溢出区等方法。

开放定址法

从发生冲突的那个单元起，按照一定的次序，从哈希表中找到一个空闲的单元。然后把发生冲突的元素存入到该单元的一种方法。开放定址法需要的表长度要大于等于所需要存放的元素。在开放定址法中解决冲突的方法有：线行探查法、平方探查法、双散列函数探查法。开放定址法的缺点在于删除元素的时候不能真的删除，否则会引起查找错误，只能做一个特殊标记。只到有下个元素插入才能真正删除该元素。

线行探查法

线行探查法是开放定址法中最简单的冲突处理方法，它从发生冲突的单元起，依次判断下一个单元是否为空，当达到最后一个单元时，再从表首依次判断。直到碰到空闲的单元或者探查完全部单元为止。

平方探查法

平方探查法即是发生冲突时，用发生冲突的单元d[i], 加上 1²、 2²等。即d[i] + 1²，d[i] + 2², d[i] + 3²…直到找到空闲单元。在实际操作中，平方探查法不能探查到全部剩余的单元。不过在实际应用中，能探查到一半单元也就可以了。若探查到一半单元仍找不到一个空闲单元，表明此散列表太满，应该重新建立。

双散列函数探查法

这种方法使用两个散列函数hl和h2。其中hl和前面的h一样，以关键字为自变量，产生一个0至m—l之间的数作为散列地址；h2也以关键字为自变量，产生一个l至m—1之间的、并和m互素的数(即m不能被该数整除)作为探查序列的地址增量(即步长)，探查序列的步长值是固定值l；对于平方探查法，探查序列的步长值是探查次数i的两倍减l；对于双散列函数探查法，其探查序列的步长值是同一关键字的另一散列函数的值。

链地址法（拉链法）

链接地址法的思路是将哈希值相同的元素构成一个同义词的单链表，并将单链表的头指针存放在哈希表的第i个单元中，查找、插入和删除主要在同义词链表中进行。链表法适用于经常进行插入和删除的情况。

如何解决并发问题？

应用场景建议方案？

每日问题：

0309

Map存储特点？

map是关联键值对关系的集合；

Key(键) : 是无序的,去重的,唯一的；

Value(值): 是无序的.可重复的；

键值可是为任意引用数据类型；

一个key对应一个value. 如果对一个key进行了多次put,后面的将覆盖前面的；

HashMap的底层存储方式？

jdk1.8之前底层实现是数组加链表；

过程：

**1.**调用put方法添加键值对key,value数据

**2.**根据key计算hash值

int hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

**3.**调用putVal(hash,key,value)实现存储键值对数据

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

**5.**根据key的hash值计算位桶索引int index = (n - 1) & hash,判断table[index]==null是否存在单向链表的首节点

if ((p = tab[i = (n - 1) & hash]) == null)

**6.**如果=null,证明不存在单向链表,直接创建新节点,存储这一次要添加的键值对数据,直接放在数组table[index]作为单向链表的首节点

tab[i] = newNode(hash, key, value, null); --> new Node<>(hash, key, value, next)

**7.**如果!=null,证明存在单向链表的首节点,遍历这个链表,判断链表中每一个节点的存储的key与这一次要添加的键值对的key比较是否相等,

if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))

如果相同value覆盖

V oldValue = e.value;
e.value = value;
return oldValue;

如果不相同创建新节点,挂在原单向链表的最后

p.next = newNode(hash, key, value, null);

**8.**如果以上的步骤中执行到了new Node()创建新节点放入哈希表中,数据个数+1,判断是否>扩容阈值threshold,如果满足,就调用resize方法实现扩容

if (++size > threshold)

resize();

什么是hash碰撞？

如何解决hash碰撞？

解决哈希冲突的方法

解决哈希冲突的方法一般有：开放定址法、链地址法（拉链法）、再哈希法、建立公共溢出区等方法。

开放定址法

线行探查法

平方探查法

双散列函数探查法

链地址法（拉链法）

如何解决并发问题？

应用场景建议方案？

0310

程序、进程、线程之间的区别和联系？

1）进程是程序及其数据在计算机的一次运行活动，是一个运行过程，是一个动态的概念。进程的运行实体是程序，离开程序的进程没有存在的意义。而程序是一组有序的指令集合，是一种静态概念。

2）进程是程序的一次执行过程，它是动态地创建和消亡的，具有一定的生命周期，是暂时存在的；而程序则是一组代码的集合，它是永久存在的，可长期保存。

3）一个进程可以执行一个或几个程序，一个程序也可以构成多个进程。进程可以创建进程，而程序不能形成新的程序。

4）进程和程序的组成不同。从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。而程序是一组有序的指令集合©著作权归作者所有：来自51CTO博客作者姜兴琪的原创作品，请联系作者获取转载授权，否则将追究法律责任

进程与程序的区别和联系

为什么要使用多线程？

选择多线程的原因就是一个快字，使用多线程就是在正确的场景下通过设置正确个数的线程来最大化程序的运行速度。

充分的利用 CPU 和 I/O 的利用率

合理的场景+合理的线程数得到运行效率的提升。

具体来说：

1、多线程和进程相比，它是一种非常花销小，切换快，更"节俭"的多任务操作方式。

在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。

而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，

而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。

2、方便的通信机制。

对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。

线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。

当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。

原文链接：https://blog.csdn.net/JMW1407/article/details/107222065

为什么要使用多线程？

线程的创建方式有哪些？

（1）继承Thread类并重写run()方法；

（2）实现Runnable接口；

（3）匿名内部类；

（4）实现Callabe接口；

（5）定时器（java.util.Timer）；

（6）线程池；

（7）并行计算（Java8+）；

（8）Spring异步方法；

参考https://developer.aliyun.com/article/720284

如何完成线程的通信？以及它的通信机制有哪些？

线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机制。

锁机制：包括互斥锁、条件变量、读写锁、自旋锁

wait/notify等待

Volatile内存共享

信号量机制（Semaphore）

信号机制（Signal）

https://blog.csdn.net/J080624/article/details/87454764

https://juejin.cn/post/6969122698563682311

==拓展==

请详细描述一下线程的状态？

新建状态:

使用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序start()这个线程。

就绪状态:

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态:

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态:

如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态:

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

如何能够保证更加高效的使用线程？

Java提供了不同层面的线程安全支持。在传统集合框架内部，除了Hashtable等同步容器，还提供了所谓的同步包装器（Synchronized Wrapper），我们可以调用Collections工具类提供的包装方法，来获取一个同步的包装容器（Collections.synchronizedMap），但是它们都是利用非常粗粒度的同步方式，在高并发情况下，性能比较低下

另外，更加普遍的选择是利用并发包提供的线程安全容器类，它提供了：

各种并发容器，比如ConcurrentHashMap、CopyOnWriteArrayList

各种线程安全队列（Queue/Deque），如ArrayBlockingQueue、SynchronousQueue

各种有序容器的线程安全版本等。

具体保证线程安全的方式，包括有从简单的synchronize方式，到基于更加精细化的，比如基于分离锁实现的ConcurrentHashMap等并发实现等。具体选择要看开发的场景需求，总体来说，并发包内提供的容器通用场景，远优于早期的简单同步实现。

阿里巴巴待招录工程师

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《每日问题》

在计算hash地址的过程中会出现对于不同的关键字出现相同的哈希地址的情况，即key1 ≠ key2，但是f(key1) = f(key2)，这种情况就是Hash 冲突。具有相同关键字的key1和key2称之为同义词。通过优化哈希函数可以减少这种冲突的情况（如：均衡哈希函数），但是在通用条件下，考虑到于表格的长度有限及关键值（数据）的无限，这种冲突是不可避免的，所以就需要处理冲突。
复制链接

扫一扫