秋招java面试题总结2（自用）

LzlGo

于 2022-10-09 11:01:59 发布

阅读量385

点赞数 1

文章标签： java 面试开发语言

本文链接：https://blog.csdn.net/weixin_45021495/article/details/127214476

版权

16.内存管理

得分点段页式内存管理方式

标准回答
Linux 操作系统是采用段页式内存管理方式：页式存储管理能有效地提高内存利用率（解决内存碎片）,而分段存储管理能反映程序的逻辑结构并有利于段的共享。将这两种存储管理方法结合起来,就形成了段页式存储管理方式。

段页式存储管理方式先将用户程序分成若干个段,再把每个段分成若干个页,并为每一个段赋予一个段名。在段页式系统中,为了实现从逻辑地址到物理地址的转换,系统中需要同时配置段表和页表,利用段表和页表进行从用户地址空间到物理内存空间的映射。

17.请你说说IO多路复用（select、poll、epoll）

解题思路
得分点概念、select、poll、epoll

标准回答 I/O 多路复用是一种使得程序能同时监听多个文件描述符的技术,从而提高程序的性能。

IO多路复用指的是单个进程或者线程能同时处理多个IO请求，select，epoll，poll是LinuxAPI提供的复用方式。本质上由操作系统内核缓冲IO数据，使得单个进程线程能监视多个文件描述符。select是将装有文件描述符的集合从用户空间拷贝到内核空间，底层是数组，poll和select差距不大，但是底层是链表，这就代表没有上限，而select有数量限制。epoll则是回调的形式，底层是红黑树，避免轮询，时间复杂度从O（n）变为O（1）

18.请你说说线程和协程的区别

标准回答

线程是操作系统的资源,线程的创建、切换、停止等都非常消耗资源,而创建协程不需要调用操作系统的功能,编程语言自身就能完成,所以协程也被称为用户态线程,协程比线程轻量很多；
线程在多核环境下是能做到真正意义上的并行,而协程是为并发而产生的；
一个具有多个线程的程序可以同时运行几个线程,而协同程序却需要彼此协作的运行；
线程进程都是同步机制,而协程则是异步；
线程是抢占式,而协程是非抢占式的,所以需要用户自己释放使用权来切换到其他协程,因此同一时间其实只有一个协程拥有运行权,相当于单线程的能力；
操作系统对于线程开辟数量限制在千的级别,而协程可以达到上万的级别。

19.请你说说MySQL的事务隔离级别

得分点未提交读、已提交读、可重复读、可串行化

标准回答 SQL 标准定义了四种隔离级别,这四种隔离级别分别是：

读未提交（READ UNCOMMITTED）； - 读提交（READ COMMITTED）；
可重复读（REPEATABLE READ）； - 串行化（SERIALIZABLE）。

事务隔离是为了解决脏读、不可重复读、幻读问题,下表展示了 4 种隔离级别对这三个问题的解决程度：

隔离级别	脏读	不可重复读	幻读
READ UNCOMMITTED	可能	可能	可能
READ COMMITTED	不可能	可能	可能
REPEATABLE READ	不可能	不可能	可能
SERIALIZABLE	不可能	不可能	不可能

上述4种隔离级别MySQL都支持,并且InnoDB存储引擎默认的支持隔离级别是REPEATABLE READ,但是与标准SQL不同的是,InnoDB存储引擎在REPEATABLE READ事务隔离级别下,使用Next-Key Lock的锁算法,因此避免了幻读的产生。所以,InnoDB存储引擎在默认的事务隔离级别下已经能完全保证事务的隔离性要求,即达到SQL标准的SERIALIZABLE隔离级别；

加分回答

READ UNCOMMITTED：它是性能最好、也最野蛮的方式,因为它压根儿就不加锁,所以根本谈不上什么隔离效果,可以理解为没有隔离。
SERIALIZABLE：读的时候加共享锁,其他事务可以并发读,但是不能写。写的时候加排它锁,其他事务不能并发写也不能并发读。
REPEATABLE READ & READ COMMITTED：为了解决不可重复读,MySQL 采用了 MVVC (多版本并发控制) 的方式。

20.如何利用Redis实现一个分布式锁？

得分点为什么要实现分布式锁、实现分布式锁的方式

标准回答
在分布式的环境下,会发生多个server并发修改同一个资源的情况,这种情况下,由于多个server是多个不同的JRE环境,而Java自带的锁局限于当前JRE,所以Java自带的锁机制在这个场景下是无效的,那么就需要我们自己来实现一个分布式锁。

方案一：SETNX + EXPIRE
方案二：SETNX + value值是（系统时间 + 过期时间）
方案三：使用Lua脚本（包含SETNX + EXPIRE两条指令）
方案四：SET的扩展命令（SET EX PX NX）
方案五：SET EX PX NX + 校验唯一随机值，再释放锁
方案六：开源框架：Redisson
方案七：多机实现的分布式锁Redlock
参考牛客

21.请说说你对反射的了解

得分点反射概念,通过反射机制可以实现什么

标准回答
Java程序中,许多对象在运行时都会有编译时异常和运行时异常两种,例如多态情况下Car c = new Audi(); 这行代码运行时会生成一个c变量,在编译时该变量的类型是Car,运行时该变量类型为Audi；
另外还有更极端的情况,例如程序在运行时接收到了外部传入的一个对象,这个对象的编译时类型是Object,但程序又需要调用这个对象运行时类型的方法

这种情况下,有两种解决方法：第一种做法是假设在编译时和运行时都完全知道类型的具体信息,在这种情况下,可以先使用instanceof运算符进行判断,再利用强制类型转换将其转换成其运行时类型的变量。
第二种做法是编译时根本无法预知该对象和类可能属于哪些类,程序只依靠运行时信息来发现该对象和类的真实信息,这就必须使用反射。具体来说,通过反射机制,我们可以实现如下的操作：

程序运行时,可以通过反射获得任意一个类的Class对象,并通过这个对象查看这个类的信息；
程序运行时,可以通过反射创建任意一个类的实例,并访问该实例的成员；
程序运行时,可以通过反射机制生成一个类的动态代理类或动态代理对象。

加分回答 Java的反射机制在实际项目中应用广泛,常见的应用场景有：

使用JDBC时,如果要创建数据库的连接,则需要先通过反射机制加载数据库的驱动程序；
多数框架都支持注解/XML配置,从配置中解析出来的类是字符串,需要利用反射机制实例化；
面向切面编程（AOP）的实现方案,是在程序运行时创建目标对象的代理类,这必须由反射机制来实现。

22.请你说说ArrayList和LinkedList的区别

得分点数据结构、访问效率

标准回答

ArrayList的实现是基于数组,LinkedList的实现是基于双向链表。
对于随机访问ArrayList要优于LinkedList,ArrayList可以根据下标以O(1)时间复杂度对元素进行随机访问,而LinkedList的每一个元素都依靠地址指针和它后一个元素连接在一起,查找某个元素的时间复杂度是O(N)。
对于插入和删除操作,LinkedList要优于ArrayList,因为当元素被添加到LinkedList任意位置的时候,不需要像ArrayList那样重新计算大小或者是更新索引。
LinkedList比ArrayList更占内存,因为LinkedList的节点除了存储数据,还存储了两个引用,一个指向前一个元素,一个指向后一个元素。

23.请你说说聚簇索引和非聚簇索引

得分点索引即数据、二次查询

标准回答两者主要区别是数据和索引是否分离。

聚簇索引是将数据与索引存储到一起,找到索引也就找到了数据；
而非聚簇索引是将数据和索引存储分离开,索引树的叶子节点存储了数据行的地址。
在InnoDB中,一个表有且仅有一个聚簇索引（因为原始数据只留一份,而数据和聚簇索引在一起）,并且该索引是建立在主键上的,即使没有指定主键,也会特殊处理生成一个聚簇索引；其他索引都是辅助索引,使用辅助索引访问索引外的其他字段时都需要进行二次查找。而在MyISAM中,所有索引都是非聚簇索引,叶子节点存储着数据的地址,对于主键索引和普通索引在存储上没有区别。

24.数据库为什么不用红黑树而用B+树？

得分点磁盘IO

标准回答

红黑树是一种近似平衡二叉树（不完全平衡）,结点非黑即红的树,它的树高最高不会超过 2*log(n),因此查找的时间复杂度为 O(log(n)),无论是增删改查,它的性能都十分稳定；但是,红黑树本质还是二叉树,在数据量非常大时,需要访问+判断的节点数还是会比较多,同时数据是存在磁盘上的,访问需要进行磁盘IO,导致效率较低；
而B+树是多叉的,可以有效减少磁盘IO次数；同时B+树增加了叶子结点间的连接,能保证范围查询时找到起点和终点后快速取出需要的数据。

加分回答红黑树做索引底层数据结构的缺陷

试想一下,以红黑树作为底层数据结构在面对在些表数据动辄数百万数千万的场景时,创建的索引它的树高得有多高？索引从根节点开始查找,而如果我们需要查找的数据在底层的叶子节点上,那么树的高度是多少,就要进行多少次查找,数据存在磁盘上,访问需要进行磁盘IO,这会导致效率过低；那么红黑树作为索引数据结构的弊端即是：树的高度过高导致查询效率变慢。

25.请你说说Redis的数据类型

得分点 string、hash、list、set、zset

标准回答
Redis主要提供了5种数据结构：字符串(String)、列表(List)、哈希(Hash)、集合(set)、有序集合(zset)。

String是一组字节。在 Redis 数据库中,字符串是二进制安全的。这意味着它们具有已知长度,并且不受任何特殊终止字符的影响。可以在一个字符串中存储最多 2 兆字节的内容。
Redis 列表定义为字符串列表,按插入顺序排序。可以将元素添加到 Redis 列表的头部或尾部。
哈希是键值对的集合。在 Redis 中,哈希是字符串字段和字符串值之间的映射。因此,它们适合表示对象。
集合（set）是 Redis 数据库中的无序字符串集合。
Redis 有序集合类似于 Redis 集合,也是一组非重复的字符串集合。但是,排序集的每个成员都与一个分数相关联,该分数用于获取从最小到最高分数的有序排序集。虽然成员是独特的,但可以重复分数。

加分回答
Redis还提供了Bitmap、HyperLogLog、Geo类型,但这些类型都是基于上述核心数据类型实现的。5.0版本中,Redis新增加了Streams数据类型,它是一个功能强大的、支持多播的、可持久化的消息队列。

26.***请你讲讲工厂模式,手写实现工厂模式

得分点简单工厂、工厂方法、抽象工厂

标准回答
工厂模式（Factory Method Pattern）也叫虚拟构造函数模式或多态性工厂模式,其用意是定义一个创建产品对象的工厂接口,将实际创建性工作推迟到子类中。
工厂模式可以分为简单工厂、工厂方法和抽象工厂模式。

1.简单工厂模式严格来讲并不算是一种设计模式,更多的时候是一种编程习惯。简单工厂的实现思路是,定义一个工厂类,根据传入的参数不同返回不同的实例,被创建的实例具有共同的父类或接口。简单工厂适用于需要创建的对象较少或客户端不关心对象的创建过程的情况。

/*`示例： 创建一个可以绘制不同形状的绘图工具,可以绘制圆形,正方形,三角形,每个图形都会有一个draw()方法
用于绘图,首先可以定义一个接口或者抽象类,作为这三个图像的公共父类,并在其中声明一个公共的draw方法：*/
public interface Shape { 
 	void draw();
 } 
 // 下面就是编写具体的图形,每种图形都实现Shape接口： 
 // 圆形
class CircleShape implements Shape {
	public CircleShape() { 
		System.out.println("CircleShape: created"); 
	} 
	@Override 
	public void draw() { 
		System.out.println("draw: CircleShape"); 
	} 
} 
// 正方形 
class RectShape implements Shape { 
	public RectShape() { 
		System.out.println("RectShape: created"); 
	} 
	@Override 
	public void draw() { 
	System.out.println("draw: RectShape"); 
	} 
} 
// 三角形 
public class TriangleShape implements Shape { 
	public TriangleShape() { 
		System.out.println("TriangleShape: created"); 
		} 
		@Override 
		public void draw() { 
			System.out.println("draw: TriangleShape"); 
		} 
} 
//下面是工厂类的具体实现： 
class ShapeFactory { 
	public static Shape getShape(String type) { 
		Shape shape = null; 
		if (type.equalsIgnoreCase("circle")) { 
			shape = new CircleShape(); 
		} else if (type.equalsIgnoreCase("rect")) { 
			shape = new RectShape(); 
		} else if (type.equalsIgnoreCase("triangle")) { 
			shape = new TriangleShape(); 
		} 
		return shape; 
	} 
} 
// 为工厂类传入不同的type可以new不同的形状,返回结果为Shape 类型,这个就是简单工厂核心的地方了。

2.工厂方法模式工厂方法模式具有良好的封装性,代码结构清晰,一个对象创建是有条件约束的,如果一个调用者需要一个具体的产品对象,只要知道这个产品的类名或约束字符串即可,不用知道创建对象的过程如何,降低了模块间的耦合。工厂模式还拥有优秀的可扩展性,在增加产品类的情况下,只要适当地修改具体的工厂类或扩展一个工厂类,就可以适应变化。工厂方法模式是典型的解耦框架,高层模块只需要知道产品的抽象类或接口,其他的实现类都不用关心。

// 举个例子,通过汽车工厂来演示工厂模式： 首先创建一个Car的接口： 
public interface Car { 
	//品牌 
	public void brand(); 
	//速度
	public void speed(); 
	//价格 
	public void price(); 
} 
//再创建一个Car的抽象工厂： 
public interface CarFactory { 
	public Car factory(); 
} 
//奥迪Audi类实现Car接口,是一个具体的产品： 
public class Audi implements Car { 
	@Override 
	public void brand() { 
		System.out.println("一台奥迪"); 
	} 
	@Override 
	public void speed() { 
		System.out.println("快"); 
	} 
	@Override public void price() { 
		System.out.println("贵"); 
	} 
} 
//奥拓Auto类实现Car接口,是一个具体的产品： 
public class Auto implements Car{ 
	@Override public void brand() { 
		System.out.println("一台奥拓"); 
	} 
	@Override public void speed() { 
		System.out.println("慢"); 
	}
	@Override public void price() { 
		System.out.println("便宜"); 
	}
} 
// 奥迪工厂AudiFactory实现CarFactory接口,专门用于生产奥迪： 
public class AudiFactory implements CarFactory { 
	@Override 
	public Car factory() { 
		return new Audi(); 
	} 
} 
// 奥拓工厂AutoFactory实现CarFactory接口,专门用于生产奥拓： 
public class AutoFactory implements CarFactory { 
	@Override 
	public Car factory() { 
		return new Auto(); 
	} 
} 
// 应用场景代码： 
public class ClientDemo { 
	public static void mn(String[] args) { 
		CarFactory carFactory= new AudiFactory(); 
		// 返回Car属性
		Car audi = carFactory.factory(); 
		audi.brand(); 
		audi.speed(); 
		audi.price(); 
		carFactory=new AutoFactory();
		Car auto = carFactory.factory(); 
		auto.brand(); 
		auto.speed(); 
		auto.price(); 
	}
} 
//运行结果为： 一台奥迪 快 贵 一台奥拓 慢 便宜

抽象工厂模式（Abstract Factory Pattern）是一种比较常用的模式。为创建一组相关或相互依赖的对象提供一个接口,而且无须指定它们的具体类。抽象工厂模式是工厂方法模式的升级版本。在有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式,抽象方法适用于下和工厂方法一样客户端不需要知道它所创建的对象的类,需要一组对象共同完成某种功能,可能存在多组对象完成不同功能以及系统结构稳定,不会频繁的增加对象的情况。

/*这里举个例子： 
现在需要做一款跨平台的游戏,需要兼容Android,Ios,Wp三个移动操作系统,该游戏针对每个系统都设计了一套操作
控制器（OperationController）和界面控制器（UIController）,下面通过抽闲工厂方式完成这款游戏的架构设
计。 由题可知,游戏里边的各个平台的UIController和OperationController应该是我们最终生产的具体产品。
所以新建两个抽象产品接口。*/ 
//抽象操作控制器： 
interface OperationController { 
	void control(); 
} 
// 抽象界面控制器： 
interface UIController { 
	void display(); 
} 
//然后完成各个系统平台的具体操作控制器和界面控制器。 
//Android： 
class AndroidOperationController implements OperationController { 
	@Override 
	public void control() { 
		System.out.println("AndroidOperationController"); 
	} 
} 
class AndroidUIController implements UIController { 
	@Override public void display() { 
		System.out.println("AndroidInterfaceController"); 
	} 
} 
//IOS： 
class IosOperationController implements OperationController { 
	@Override 
	public void control() { 
		System.out.println("IosOperationController"); 
	} 
} 
class IosUIController implements UIController { 
	@Override 
	public void display() { 
		System.out.println("IosInterfaceController"); 
	} 
} 
//WP： 
class WpOperationController implements OperationController { 
	@Override public void control() { 
		System.out.println("WpOperationController"); 
	} 
} 
class WpUIController implements UIController { 
	@Override 
	public void display() { 
		System.out.println("WpInterfaceController");
	}
}
// 下面定义一个抽闲工厂,该工厂需要可以创建OperationController和UIController。 
public interface SystemFactory { 
	public OperationController createOperationController(); 
	public UIController createInterfaceController(); 
} 
//在各平台具体的工厂类中完成操作控制器和界面控制器的创建过程。 
//Android： 
public class AndroidFactory implements SystemFactory { 
	@Override
	public OperationController createOperationController() { 
		return new AndroidOperationController(); 
	} 
	@Override 
	public UIController createInterfaceController() {
		return new AndroidUIController(); 
	} 
} 
//IOS： 
public class IosFactory implements SystemFactory { 
	@Override 
	public OperationController createOperationController() { 
		return new IosOperationController(); 
	}
	@Override 
	public UIController createInterfaceController() { 
		return new IosUIController(); 
	}
} 
//WP： 
public class WpFactory implements SystemFactory { 
	@Override 
	public OperationController createOperationController() { 
		return new WpOperationController(); 
	} 
	@Override public UIController createInterfaceController() { 
		return new WpUIController(); 
	} 
}

加分回答简单工厂模式其实并不算是一种设计模式,更多的时候是一种编程习惯。简单工厂的实现思路是,定义一个工厂类,根据传入的参数不同返回不同的实例,被创建的实例具有共同的父类或接口。工厂方法模式是简单工厂的仅一步深化, 在工厂方法模式中,我们不再提供一个统一的工厂类来创建所有的对象,而是针对不同的对象提供不同的工厂。也就是说每个对象都有一个与之对应的工厂。工厂方法的实现思路是,定义一个用于创建对象的接口,让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。抽象工厂模式是工厂方法的仅一步深化,在这个模式中的工厂类不单单可以创建一个对象,而是可以创建一组对象。这是和工厂方法最大的不同点。抽象工厂的实现思路是,提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。

27.你知道哪些线程安全的集合？

得分点 Collections、java.util.concurrent (JUC)

标准回答
java.util包下的集合类中,大部分都是非线程安全的,例如：ArrayList/LinkedList/HashMap等等。
但也有少数的线程安全的集合类,例如Vector、Hashtable,它们都是非常古老的API。虽然它们是线程安全的,但是性能很差,已经不推荐使用了。
对于这个包下非线程安全的集合,可以利用Collections工具类,该工具类提供的synchronizedXxx()方法,可以将这些集合类包装成线程安全的集合类。

从JDK 1.5开始,并发包下新增了大量高效的并发的容器,这些容器按照实现机制可以分为三类。
第一类是以降低锁粒度来提高并发性能的容器,它们的类名以Concurrent开头,如ConcurrentHashMap。
第二类是采用写时复制技术实现的并发容器,它们的类名以CopyOnWrite开头,如CopyOnWriteArrayList。
第三类是采用Lock实现的阻塞队列,内部创建两个Condition分别用于生产者和消费者的等待,这些类都实现了BlockingQueue接口,如ArrayBlockingQueue。

28.请你说说ConcurrentHashMap

一、ConcurrentHashMap是一个线程安全的集合，它的底层数据结构与HashMap一样,也是采用“数组+链表+红黑树
二、采用锁定头节点的方式降低了锁粒度,以较低的性能代价实现了线程安全。
三、实现机制：
1. 初始化数组或头节点时,ConcurrentHashMap并没有加锁,而是CAS的方式进行原子替换
2. 插入数据时会进行加锁处理,但锁定的不是整个数组,而是槽中的头节点。所以,ConcurrentHashMap中锁的粒度是槽,而不是整个数组,并发的性能很好。
3. 扩容时会进行加锁处理,锁定的仍然是头节点。并且,支持多个线程同时对数组扩容,提高并发能力。
4. 在扩容的过程中,依然可以支持查找操作。

28.说说缓存穿透、击穿、雪崩的区别

缓存穿透：客户端访问不存在的数据，使得请求直达存储层，导致负载过大，直至宕机。原因可能是业务层误删了缓存和库中的数据，或是有人恶意访问不存在的数据。
解决方式：
1.存储层未命中后，返回空值存入缓存层，客户端再次访问时，缓存层直接返回空值。
2.将数据存入布隆过滤器，访问缓存之前经过滤器拦截，若请求的数据不存在则直接返回空值。
缓存击穿：一份热点数据，它的访问量非常大，在它缓存失效的瞬间，大量请求直达存储层，导致服务崩溃。
解决方案：
1.永不过期：对热点数据不设置过期时间。
2.加互斥锁，当一个线程访问该数据时，另一个线程只能等待，这个线程访问之后，缓存中的数据将被重建，届时其他线程就可以从缓存中取值。
缓存雪崩：大量数据同时过期、或是redis节点故障导致服务不可用，缓存层无法提供服务，所有的请求直达存储层，造成数据库宕机。
解决方案：
1.避免数据同时过期，设置随机过期时间。
2.启用降级和熔断措施。
3.设置热点数据永不过期。
4.采用redis集群，一个宕机，另外的还能用