面试总结

最新推荐文章于 2023-03-07 00:33:46 发布

英俊帅比林

最新推荐文章于 2023-03-07 00:33:46 发布

阅读量485

点赞数 2

分类专栏： Java 文章标签： java 面试

本文链接：https://blog.csdn.net/qq_37856300/article/details/95767227

版权

Java 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

常见面试题总结

https://github.com/doocs/advanced-java

1.hashcode 和 equals 方法的作用和联系

https://blog.csdn.net/bailu666666/article/details/81153815

总结： hashcode和equals都是为了判断对象是否相等，hashcode相同对象也可能不相等，所以自定义的对象需要重写hashcode()方法来确保一些数据结构如set中没有重复元素；equals()判断两个对象是否相等要比hashcode()慢，如果两个对象的hashcode不相等，那么他们一定不等，如果hashcode相等，再通过equals去判断相等，这样可以加快一些速度。

2.对hashmap的了解

https://blog.csdn.net/qq_37856300/article/details/88802096

https://blog.csdn.net/qq_30683329/article/details/80455779

https://blog.csdn.net/suifeng629/article/details/82179996

数据结构：
java1.7——链表+桶 O(n)
java1.8——红黑树 O(logn)

hash算法：
使用对象的 hashcode 对桶的个数-1 进行与运算

使用注意事项：
hashmap 默认分配的空间是2的幂（为了不造成空间浪费）使用时如果自定义分配空间分配的空间应是2的幂同时大于等于桶个数 x loadFactor(默认为0.75) （为了不频繁扩容耗费性能）

扩容：
java1.7——将原数组的结点一一进行hash计算，然后一一挂接到新数组上
java1.8——将原数组每个结点的hash值和原数组长度进行“与”操作,结果等于0代表该结点位置不变，落在新数组的同样位置，否则该结点在新数组的位置是结果值+原数组长度的位置上

并发问题：
Hashmap的Resize包含扩容和ReHash两个步骤，ReHash在并发的情况下可能会形成链表环。因为，链表采用头插法，将原数组转移到新数组时，会从前向后遍历链表结点，头插法机制恰好使新数组中结点的相对顺序和原数组中颠倒过来。在并发的时候，假如原来的结点顺序被线程A颠倒了，而被挂起的线程b在恢复执行后，拿扩容前的节点和顺序继续完成第一次循环，而后又遵循A线程扩容后的链表顺序重新排列链表中的顺序，即又颠倒了一下顺序，最终形成了环。

concurrentHashmap统计size：
https://blog.csdn.net/chenyiminnanjing/article/details/82716180

既然红黑树那么好，为啥hashmap不直接采用红黑树，而是当大于8个的时候才转换红黑树？
因为红黑树需要进行左旋，右旋操作，而单链表不需要，
以下都是单链表与红黑树结构对比。
如果元素小于8个，查询成本高，新增成本低
如果元素大于8个，查询成本低，新增成本高

当个数不多的时候，直接链表遍历更方便，实现起来也简单。而红黑树的实现要复杂的多。

3.面向对象的特点是什么，分别解释下？面向对象的六大原则？

特点： 封装，继承，多态 https://blog.csdn.net/qq_38900441/article/details/80751686

六大原则： https://www.cnblogs.com/itfenqing/p/7750524.html

单一职责：要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。

里氏代换原则：所有引用基类的地方必须能透明地使用其子类的对象，也就是说子类可以扩展父类的功能，但不能改变父类原有的功能

依赖倒置：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。简单的说就是尽量面向接口编程

接口隔离：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。接口最小化,过于臃肿的接口依据功能,可以将其拆分为多个接口.

迪米特法则：一个对象应该对其他对象保持最少的了解,简单的理解就是高内聚,低耦合，一个类尽量减少对其他对象的依赖，并且这个类的方法和属性能用私有的就尽量私有化.

开闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭.当软件需求变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化.

4.不用多态不行吗？多态有什么好处？

什么是多态？

概念：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。简单的说:就是用基类的引用指向子类的对象。

为什么要用多态呢？

原因：我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态除了代码的复用性外，还可以解决项目中紧偶合的问题,提高程序的可扩展性.。耦合度讲的是模块模块之间，代码代码之间的关联度，通过对系统的分析把他分解成一个一个子模块，子模块提供稳定的接口，达到降低系统耦合度的的目的，模块模块之间尽量使用模块接口访问，而不是随意引用其他模块的成员变量。

多态有什么好处？

有两个好处：

应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承
派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用

5.解释三次握手和四次挥手，为什么挥手比握手多一次？

https://blog.csdn.net/weixin_34405925/article/details/92405834
总结：
三次握手：
A向B发起建立连接请求：A——>B；
B收到A的发送信号，并且向A发送确认信息：B——>A；
A收到B的确认信号，并向B发送确认信号：A——>B。

通过第一次握手，B知道A能够发送数据。通过第二次握手，A知道B能发送数据。结合第一次握手和第二次握手，A知道B能接收数据。结合第三次握手，B知道A能够接收数据。

四次挥手：
A向B发起请求，表示A没有数据要发送了：A——>B；
B向A发送信号，确认A的断开请求请求：B——>A；
B向A发送信号，请求断开连接，表示B没有数据要发送了：B——>A；
A向B发送确认信号，同意断开：A——>B。

挥手次数比握手多一次，是因为握手过程，通信只需要处理连接。而挥手过程，通信需要处理数据+连接，不能让正在传输的数据中断传输。

为什么四次握手后要多等2msl时间：
https://blog.csdn.net/LF_2016/article/details/60468161

6.Mysql索引都有什么，介绍下特点，主键索引和其他索引有什么区别？为什么加了索引就快了？

https://blog.csdn.net/hollis_chuang/article/details/95167242
Mysql各种索引区别：
普通索引：最基本的索引，没有任何限制
唯一索引：与"普通索引"类似，不同的就是：索引列的值必须唯一，但允许有空值。
主键索引：它是一种特殊的唯一索引，不允许有空值。
全文索引：仅可用于 MyISAM 表，针对较大的数据，生成全文索引很耗时好空间。
组合索引：为了更多的提高mysql效率可建立组合索引，遵循”最左前缀“原则。创建复合索引时应该将最常用（频率）作限制条件的列放在最左边，依次递减。

where 字段从左往右顺序，数据量最少的字段放在最左边，因为这样查询次数会最少

主键索引和其他索引的区别：
索引：索引好比是一本书的目录，可以快速的通过页码找到你需要的那一页。惟一地标识一行。

主键：做为数据库表唯一行标识，作为一个可以被外键有效引用的对象。

索引是一种特殊的文件(InnoDB数据表上的索引是表空间的一个组成部分)，它们包含着对数据表里所有记录的引用指针。索引可以大大提高MySQL的检索速度。

主键是特殊的索引，主键是索引，索引不一定是主键，索引可以是多列，主键只能是一列。

复合索引失效：https://www.cnblogs.com/sweet-ice/articles/10507420.html
a = 1, b>2, c = 3 能用上 a, b, c 索引吗 能用上一部分，根据最左前缀匹配原则，mysql会一直向右匹配直到遇到范围查询(>、<、between、like)就停止匹配，c 是用不到索引的。

为什么用B+树当索引而不用B树：https://www.cnblogs.com/gekh/p/9965444.html

7.数据库的隔离级别、什么是幻读，脏读，不可重复读

https://baijiahao.baidu.com/s?id=1611918898724887602&wfr=spider&for=pc

隔离级别：
读未提交（Read Uncommitted）
读提交（Read Committed）
可重复读（Repeated Read）
串行化（Serializable）实现原理：通过对表加读写锁来实现最高级别事物隔离，此隔离级别下数据库失去并发能力

可重复读实现原理（MVCC）：https://www.cnblogs.com/lmj612/p/10598971.html

幻读：
事务A读取与搜索条件相匹配的若干行。事务B以插入或删除行等方式来修改事务A的结果集，然后再提交。这样就会导致当A本来执行的结果包含B执行的结果，这两个本来是不相关的，对于A来说就相当于产生了“幻觉”
脏读：
也就是当数据库的一个事务A正在使用一个数据但还没有提交，另外一个事务B也访问到了这个数据，还使用了这个数据，这就会导致事务B使用了事务A没有提交之前的数据
不可重复读：
在一个事务A中多次操作一个数据，在这两次或多次访问这个数据的中间，事务B也操作此数据，并使其值发生了改变，这就导致同一个事务A在两次操作这个数据的时候值不一样

8.mysql的存储引擎，Innodb和myIsam的区别

https://blog.csdn.net/qq_39717535/article/details/81587866
InnoDB：
支持事务处理等
不加锁读取
支持外键
支持行锁
不支持FULLTEXT类型的索引
不保存表的具体行数，扫描表来计算有多少行
DELETE 表时，是一行一行的删除
InnoDB 把数据和索引存放在表空间里面
跨平台可直接拷贝使用
InnoDB中必须包含AUTO_INCREMENT类型字段的索引
表格很难被压缩

MyISAM：
不支持事务，回滚将造成不完全回滚，不具有原子性
不支持外键
支持全文搜索
保存表的具体行数,不带where时，直接返回保存的行数
DELETE 表时，先drop表，然后重建表
MyISAM 表被存放在三个文件。frm 文件存放表格定义。数据文件是MYD (MYData) 。索引文件是MYI (MYIndex)引伸
跨平台很难直接拷贝
MyISAM中可以使AUTO_INCREMENT类型字段建立联合索引
表格可以被压缩

选择：
因为MyISAM相对简单所以在效率上要优于InnoDB
如果系统读多，写少。对原子性要求低。那么MyISAM最好的选择。且MyISAM恢复速度快。可直接用备份覆盖恢复。
如果系统读少，写多的时候，尤其是并发写入高的时候。InnoDB就是首选了。

9.https建立连接的过程、客户端怎么校验证书

https://blog.csdn.net/xiaofei0859/article/details/70747034

10.redis支持的数据结构，zset的数据结构

数据结构：
字符串(String)
列表(List)
哈希(hash)
集合(Set)
有序集合(zset)

set通过hashTable实现

zset跳表（skiplist）：
https://www.cnblogs.com/Elliott-Su-Faith-change-our-life/p/7545940.html
平均时间复杂度为O(log n)

跳表（skiplist）与平衡树、哈希表的比较：
skiplist和各种平衡树（如AVL、红黑树等）的元素是有序排列的，而哈希表不是有序的。因此，在哈希表上只能做单个key的查找，不适宜做范围查找。所谓范围查找，指的是查找那些大小在指定的两个值之间的所有节点。

在做范围查找的时候，平衡树比skiplist操作要复杂。在平衡树上，我们找到指定范围的小值之后，还需要以中序遍历的顺序继续寻找其它不超过大值的节点。如果不对平衡树进行一定的改造，这里的中序遍历并不容易实现。而在skiplist上进行范围查找就非常简单，只需要在找到小值之后，对第1层链表进行若干步的遍历就可以实现。

平衡树的插入和删除操作可能引发子树的调整，逻辑复杂，而skiplist的插入和删除只需要修改相邻节点的指针，操作简单又快速。

从内存占用上来说，skiplist比平衡树更灵活一些。一般来说，平衡树每个节点包含2个指针（分别指向左右子树），而skiplist每个节点包含的指针数目平均为1/(1-p)，具体取决于参数p的大小。如果像Redis里的实现一样，取p=1/4，那么平均每个节点包含1.33个指针，比平衡树更有优势。

查找单个key，skiplist和平衡树的时间复杂度都为O(log n)，大体相当；而哈希表在保持较低的哈希值冲突概率的前提下，查找时间复杂度接近O(1)，性能更高一些。所以我们平常使用的各种Map或dictionary结构，大都是基于哈希表实现的。

从算法实现难度上来比较，skiplist比平衡树要简单得多。

redis实现LRU（最近最久未使用）：
https://www.cnblogs.com/weknow619/p/10730653.html

UDP：

较快
尽最大努力交付，不保证数据包全部到达
多个数据包会走不同的路径，不按顺序到达
一些并不需要那么高的可靠性，效率和实时才是它们所关心的服务，可以选择无连接的套接字（UDP 服务），比如 DNS、即时聊天工具等。

TCP：

较慢，传输效率低，耗费资源多
TCP第一次发送成功，会把当前所走的路径记录，与接收方通信期间，只走这一条固定路径，如果路径断开，才会选择一条新路
数据包发出去一个，需要接收方确认收到，也就是接收方还要给发送方发送确认数据包
接收方没有收到数据包会重发
TCP会发送比UDP多很多的数据包，每个数据包的大小也比UDP大，除了源端口和目的端口，面向连接的套接字还包括序号、确认信号、数据偏移、控制标志（通常说的 URG、ACK、PSH、RST、SYN、FIN）、窗口、校验和、紧急指针、选项等信息；而无连接的套接字则只包含长度和校验和信息

14.八大排序

在这里插入图片描述
https://blog.csdn.net/jackesy/article/details/80135033
（快排，堆排是重点）

15.为什么使用消息队列，不同消息队列的优缺点

https://blog.csdn.net/qq_37856300/article/details/95501275
以及可以通过消息队列避免分布式事务问题

16.分布式事务

https://www.cnblogs.com/taiyonghai/p/6094350.html

17.单例模式

单例模式的写法： https://blog.csdn.net/qq_37856300/article/details/88140276

使用枚举实现单例： https://blog.csdn.net/FutureFlyme/article/details/88615638

18.volatile及原理

https://www.cnblogs.com/chenssy/p/6379280.html

在这里插入图片描述

19.synchronized及原理

https://blog.csdn.net/qq_37856300/article/details/84558386

20.static关键字作用

https://www.cnblogs.com/itcqx/p/5519464.html

21.对象锁，类锁

https://www.cnblogs.com/owenma/p/8609348.html

类锁和对象锁

22.lock锁和synchronized区别

https://www.cnblogs.com/handsomeye/p/5999362.html

synchronized：
可重入，不可中断，非公平

lock：
可重入，可中断，默认非公平（可公平）

23.分布式系统原理

https://blog.csdn.net/armygan/article/details/79964678
CAP： 一致性，可用性，分区容忍性

24.垃圾回收机制

https://blog.csdn.net/qq_37856300/article/details/84860515

https://blog.csdn.net/qq_37856300/article/details/84878133

https://blog.csdn.net/qq_37856300/article/details/84929996

25.内存分配与回收机制

https://blog.csdn.net/qq_37856300/article/details/85294670

26.jvm内存区域

https://blog.csdn.net/qq_37856300/article/details/84183572

27.聚簇索引和非聚簇索引区别

https://www.jianshu.com/p/fa8192853184

28.kafka原理

https://www.jianshu.com/p/4bf007885116

https://www.cnblogs.com/cxxjohnson/p/8921661.html

https://blog.csdn.net/qq_29186199/article/details/80827085

push，pull消息方式： https://blog.csdn.net/u012142247/article/details/81704986

为什么kafka topic多了性能不好： https://www.jianshu.com/p/98b68c97df9b 因为Kafka的每个Topic、每个分区都会对应一个物理文件。当Topic数量增加时，消息分散的落盘策略会导致磁盘IO竞争激烈成为瓶颈。而RocketMQ所有的消息是保存在同一个物理文件中的，Topic和分区数对RocketMQ也只是逻辑概念上的划分，所以Topic数的增加对RocketMQ的性能不会造成太大的影响。

29.线程的状态，wait和notify的联系

https://blog.csdn.net/qiuwenjie123/article/details/79521839
线程的5种状态： 新建，就绪，运行，阻塞，消亡

wait和sleep的区别： wait不持有锁，sleep持有锁

线程中断的理解： https://blog.csdn.net/xiaogutou1/article/details/47443795 线程中断不一定会抛出异常，要根据线程的状态决定

30.Springboot和SpringMVC区别

https://www.cnblogs.com/xdyixia/p/9279644.html

31.url输入地址栏发生了什么

https://www.jianshu.com/p/db17b4412eb8

32.破坏双亲委派

tomcat破坏双亲委派：
https://blog.csdn.net/qq_38182963/article/details/78660779

33.类加载机制

https://blog.csdn.net/ln152315/article/details/79223441
加载、链接（验证、准备、解析）、初始化

https://www.cnblogs.com/malcolmfeng/p/8177030.html

如果用同一个ServiceClassLoader对象去加载同一个Class文件多次，每次加载后的Class对象为同一个！然而如果new不同的自定义ClassLoader去加载同一个Class文件，则每次会返回不同的Class对象。

注意：不能将所要加载的Class文件放到classpath目录及其任何子目录下，否则会被AppClassLoader优先加载（这是由于类加载采用双亲委派机制，同时AppClassLoader可以加载所有在classpath下的class文件），每次都是同一个AppClassLoader进行加载，因此会出现类缓存问题。

34.工厂模式

https://baijiahao.baidu.com/s?id=1621464439653310895&wfr=spider&for=pc

35.线程池

https://www.cnblogs.com/dolphin0520/p/3932921.html

https://blog.csdn.net/qq_19006739/article/details/79688506

线程池核心数设置：
https://www.cnblogs.com/warehouse/p/10810338.html

https://blog.csdn.net/u012611644/article/details/80158578

36.倒排索引

https://segmentfault.com/a/1190000019641880?utm_source=tag-newest
在这里插入图片描述

37.分库分表

https://www.cnblogs.com/butterfly100/p/9034281.html

https://mp.weixin.qq.com/s/q9SEAmdJoktN_JERxKWKHQ

38.TCP/IP七层模型

https://www.cnblogs.com/qishui/p/5428938.html
在这里插入图片描述

39.IO多路复用机制详解

https://www.cnblogs.com/welen/articles/5385837.html

40.BIO NIO AIO区别

区别：https://blog.csdn.net/luzhensmart/article/details/82230076

selector channel buffer原理： https://blog.csdn.net/pjmike233/article/details/82254000 在这里插入图片描述

select，poll，epoll：https://segmentfault.com/a/1190000003063859

41.TCP滑动窗口拥塞控制

https://blog.csdn.net/dangzhangjing97/article/details/81008836

tcp如何保证可靠性：https://blog.csdn.net/liuchenxia8/article/details/80428157

42.springAop

https://blog.csdn.net/qq_32317661/article/details/82894136

43.zookeeper原理

https://blog.csdn.net/lingbo229/article/details/81052078

44.数据库第一、二、三范式

https://zhidao.baidu.com/question/124980695.html

45.spring定时任务可能遇到的问题

@schedule 注解是springboot 常用的定时任务注解,使用起来简单方便,但是如果定时任务非常多,或者有的任务很耗时,会影响到其他定时任务的执行,因为schedule 默认是单线程的,一个任务在执行时,其他任务是不能执行的.解决办法是重新配置schedule,改为多线程执行.而且spring默认定时任务貌似不能分布式

46.乐观锁悲观锁

https://www.imooc.com/article/details/id/44217

mysql数据库实现乐观锁：https://www.jianshu.com/p/5a081ff5de58

47.cglib动态代理

https://www.cnblogs.com/linghu-java/p/8892294.html
Cglib动态代理执行代理方法效率之所以比JDK的高是因为Cglib采用了FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个Class，这个Class会为代理类或被代理类的方法分配一个index(int类型)。
这个index当做一个入参，FastClass就可以直接定位要调用的方法直接进行调用，这样省去了反射调用，所以调用效率比JDK动态代理通过反射调用高。

48.Bean的生命周期

https://www.jianshu.com/p/1dec08d290c1

https://www.jianshu.com/p/e57e524c99a7

49.http1.0/1.1/2.0和https的区别

https://www.sohu.com/a/161201715_714863

50.mysql行锁、表锁、读写锁

https://www.cnblogs.com/itdragon/p/8194622.html

51.Threadlocal

https://www.jianshu.com/p/98b68c97df9b

52.XSS和CSRF攻击

CSRF：https://blog.csdn.net/xiaoxinshuaiga/article/details/80766369
XSS：https://www.cnblogs.com/mao2080/p/9460397.html

53.sql左连接右连接笛卡尔积全连接内连接

https://blog.csdn.net/u014284252/article/details/47361397

54.原子类实现原理

https://www.cnblogs.com/chengxiao/p/6789109.html

55.reentrantlock实现原理

https://www.cnblogs.com/wangzhongqiu/p/8405707.html

56.ARP地址协议解析原理

https://www.cnblogs.com/csguo/p/7542944.html

57.创建四种线程池为什么有可能OOM

https://www.cnblogs.com/GarfieldEr007/p/9954877.html

58.布隆过滤器

https://www.cnblogs.com/z941030/p/9218356.html
解决无法删除的问题（Counting Bloom Filter/滑动窗口）：https://www.cnblogs.com/chenying99/p/4375174.html

59.Callable,Future,FutureTask使用

https://www.cnblogs.com/dolphin0520/p/3949310.html
https://www.cnblogs.com/xiaoxi/p/8303574.html

60.如何实现一个线程安全的单例，前提是不能加锁

https://www.jianshu.com/p/f3fae8658f13

61.AQS

https://www.jianshu.com/p/7b0e11a1e605

https://www.jianshu.com/p/da9d051dcc3d

62.redis和数据库一致性问题

https://my.oschina.net/jiagouzhan/blog/2990423

63.redis持久化RDB和AOF对比

https://www.cnblogs.com/itdragon/p/7906481.html

64.mysql主从一致性原理

https://www.cnblogs.com/exceptioneye/p/5042133.html

https://blog.csdn.net/u011207553/article/details/96487090

65.mysql事务和锁

mysql事务和锁

66.zookeeper实现分布式锁

https://www.jianshu.com/p/e6d394bbbcfb

67.CyclicBarrier和CountdownLatch的区别

CyclicBarrier可重用屏障，通过reset重置屏障点；CountdownLatch不可重用
https://www.cnblogs.com/twoheads/p/9555867.html

68.spring自动装配原理

https://www.cnblogs.com/hellokuangshen/p/11259029.html

69.手写spring事务（Threadlocal）

https://www.jianshu.com/p/1becdc376f5d

https://www.sohu.com/a/306497169_465221

70.各种分布式锁的实现以及redis和zookeeper分布式锁对比

https://www.jianshu.com/p/f8a8e49362dc

71.管理分布式session

https://www.cnblogs.com/saoyou/p/11107488.html

https://www.cnblogs.com/pheye/p/7890065.html

72.自定义类加载器

https://www.jianshu.com/p/b02d15362bbb

73.mysql查询优化

https://www.cnblogs.com/williamjie/p/9132390.html

explain语句使用：https://www.cnblogs.com/tufujie/p/9413852.html

74.接口调用超时解决办法

https://blog.csdn.net/weixin_43681591/article/details/88942889

75.线上故障排查和解决方法

https://blog.csdn.net/xlgen157387/article/details/84626152

排查死锁：https://www.cnblogs.com/aflyun/p/9194104.html

76.JIT

https://www.cnblogs.com/wzj4858/p/9109908.html

77.Redis为什么快

https://blog.csdn.net/diweikang/article/details/90264993

英俊帅比林

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
面试总结

1.hashcode 和 equals 方法的作用和联系https://blog.csdn.net/bailu666666/article/details/81153815总结： hashcode和equals都是为了判断对象是否相等，hashcode不同对象也可能相等，所以自定义的对象需要重写hashcode()方法来确保一些数据结构如set中没有重复元素；equals()判断两个对象是否相...
复制链接

扫一扫