1.HashMap的实现原理（3次）
JDK 1.7 ： Table数组+ Entry链表；
JDK1.8 : Table数组+ Entry链表/红黑树；

2.String是怎么保持固定不变的？（1次）
String类底层是字符数组，数组是被final修饰的

3.MySQL的引擎都有哪些，他们有什么区别？（9次）
InnoDB和MyISAM;
1.InnoDB支持事务，MyISAM不支持事务；
2.InnoDB支持行级锁，MyISAM支持表级锁；
3.InnoDB支持多版本并发控制, 而MyISAM不支持；
4.InnoDB支持外键，而MyISAM不支持；
5.InnoDB不支持全文索引，而MyISAM支持。

4.数据库中建立索引的原则有哪些？（2次）
1.	定义主键的数据列一定要建立索引。
2.	定义有外键的数据列一定要建立索引。
3.	对于经常查询的数据列最好建立索引。
4.	对于需要在指定范围内的快速或频繁查询的数据列建立索引;
5.	经常用在WHERE子句中的数据列建立索引。
6.	经常出现在关键字order by、group by、distinct后面的字段，建立索引。
7.	对于那些查询中很少涉及的列，重复值比较多的列不要建立索引。
8.	对于定义为text、image和bit的数据类型的列不要建立索引。
9.	对于经常存取的列避免建立索引

5.#{}和${}的区别？（15次）
#{}将传入的数据都当成一个字符串，会对传入的数据自动加上引号；${}将传入的数据直接生成在SQL中。使用$占位符可能会导致SQL注射攻击，能用#的地方就不要使用$，写order by子句的时候应该用$而不是#。

6.SVN和Git的区别（1次）
（1）Git是分布式的，SVN不是；
（2）Git把内容按元数据方式存储，SVN是按文件；
（3）Git和SVN的分支不同：在SVN中分支就是版本库中的另外一个目录。
（4）Git没有一个全局的版本号，SVN有。
（5）Git的内容完整性要优于SVN，Git的内容存储使用的是SHA-1哈希算法，这能确保代码内容的完整性，确保在遇到磁盘故障和网络问题时降低对版本库的破坏。

7.Spring事务的传播行为（7次）
REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
REQUERS_NEW:新建事务，如果当前在事务中，把当前事务挂起。
NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER:以非事务方式运行，如果当前存在事务，抛出异常
NESTED:如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作。

8.Redis的value的数据类型都有哪些？（24次）
1、字符串（String）
2、哈希（hash）
3、字符串列表（list）
4、字符串集合（set）
5、有序字符串集合（sortedset）

9.SortedSet怎么保证成员的有序性？（1次）
SortedSet中的每一个成员都会有一个分数(score)与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序

10.介绍一下Dubbox（2次）
Dubbox是一种高性能，基于Java的开源RPC框架。

11.软负载均衡算法都有哪些？（1次）
（1）轮询。作为非常经典的负载均衡策略，早期该策略应用地非常广泛。其原理很简单，给每个请求标记一个序号，然后将请求依次派发到服务器节点中，适用于集群中各个节点提供服务能力等同且无状态的场景。其缺点也非常明显，该策略将节点视为等同，与实际中复杂的环境不符。加权轮询为轮询的一个改进策略，每个节点会有权重属性，但是因为权重的设置难以做到随实际情况变化，仍有一定的不足。
（2）随机。与轮询相似，只是不需要对每个请求进行编号，每次随机取一个。同样地，该策略也将后端的每个节点是为等同的。另外同样也有改进的加权随机的算法，不再赘述。
（3）最小响应时间。通过记录每次请求所需的时间，得出平均的响应时间，然后根据响应时间选择最小的响应时间。该策略能较好地反应服务器的状态，但是由于是平均响应时间的关系，时间上有些滞后，无法满足快速响应的要求。因此在此基础之上，会有一些改进版本的策略，如只计算最近若干次的平均时间的策略等。
（4）最小并发数。客户端的每一次请求服务在服务器停留的时间可能会有较大的差异,随着工作时间加长,如果采用简单的轮循或随机均衡算法,每一台服务器上的连接进程可能会产生较大的不同,并没有达到真正的负载均衡?最小并发数的策略则是记录了当前时刻，每个备选节点正在处理的事务数，然后选择并发数最小的节点。该策略能够快速地反应服务器的当前状况，较为合理地将负责分配均匀，适用于对当前系统负载较为敏感的场景。
（5）哈希。在后端节点有状态的情况下，需要使用哈希的方法进行负载均衡。

12.数据库的隔离级别（13次）
数据库规范规定了4种隔离级别：
read uncommitted:读未提交，一个事务读到另一个事务没有提交的数据；
read committed:读已提交，一个事务读到另一个事务已经提交的数据；
repeatable read:可重复读，在一个事务中读到的数据始终保持一致，无论另一个事务是否提交；
serializable 串行化，同时只能执行一个事务，相当于事务中的单线程；
常见数据库的默认隔离级别：
MySql：可重复读
Oracle：读已提交

13.解决线程安全问题的几种方式？（2次）
（1）同步代码块
（2）同步方法
（3）同步锁

14.介绍一下MongoDB（1次）
MongoDB 是一个跨平台的，面向文档的数据库。MongoDB 的逻辑结构是一种层次结构。主要由：文档(document)、集合(collection)、数据库(database)这三部分组成的。

15.int和Integer有什么区别？（2次） 
Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型，int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

16.SpringMVC的原理是什么？（11次）
1、用户发送请求至前端控制器；
2、前端控制器收到请求调用处理器映射器；
3、处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器一并返回给前端控制器。
4、前端控制器通过处理器适配器调用处理器。
5、执行处理器；
6、处理器执行完成返回ModelAndView；
7、处理器适配器将处理器执行结果ModelAndView返回给前端控制器；
8、前端控制器将ModelAndView传给视图解析器；
9、视图解析器解析后返回具体View；
10、前端控制器对View进行渲染视图；
11、前端控制器响应用户；

17.Hibernate与Mybatis有什么不同？（10次）
①Hibernate是全自动，而MyBatis是半自动
Hibernate完全可以通过对象关系模型实现对数据库的操作，拥有完整的JavaBean对象与数据库的映射结构来自动生成SQL语句。而MyBatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过定制SQL语句来实现和管理。
②Hibernate数据库移植性远大于MyBatis
Hibernate通过它强大的映射结构和HQL语言，大大降低了对象与数据库的耦合性，而MyBatis由于需要手写SQL，因此与数据库的耦合性直接取决于程序员写的SQL，如果SQL不具通用性而用了很多某些数据库特性的SQL语句的话，移植性也会随之降低很多，成本很高。
③Hibernate拥有完整的日志系统，MyBatis则欠缺一些。
Hibernate日志系统非常健全，涉及广泛，包括：SQL记录、关系异常、优化警告、缓存提示、脏数据警告等；而MyBatis则除了基本记录功能外，功能薄弱很多。
④MyBatis相比Hibernate需要关心很多细节
Hibernate配置要比MyBatis复杂的多，学习成本也比MyBatis高。但也正因为MyBatis使用简单，才导致它要比Hibernate关心很多技术细节。MyBatis由于不用考虑很多细节，开发模式上与传统JDBC区别很小，因此很容易上手并开发项目，但忽略细节会导致项目前期Bug较多，因而开发出相对稳定的软件很慢，而开发出软件却很快。Hibernate则正好与之相反。
5.SQL直接优化上，MyBatis要比Hibernate方便很多
由于MyBatis的SQL都是写在XML里，因此优化SQL比Hibernate方便很多。而Hibernate的SQL很多都是自动生成的，无法直接维护SQL；虽然有HQL，但功能还是不及SQL强大；Hibernate虽然也支持原生SQL，但开发模式上却与ORM不同，需要转换思维，因此使用上不是非常方便。
6.缓存机制上，Hibernate要比Mybatis更好一些
MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置，这样针对不同的表可以自定义不同的缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。
而Hibernate对查询对象有着良好的管理机制，用户无需关心SQL。所以在使用二级缓存时如果出现脏数据，系统会报出错误并提示。

18.常见的运行时异常（2次）
（1）ClassCastException 类型转换异常
（2）NullPointException 空指针异常
（3）IndexOutOfBoundException 下标越界异常
（4）ArithmeException 算数异常
（5）SecurityException 安全异常
（6）IegalArgumentException 非法参数异常

19.启动一个线程是调用run()还是start()方法？（3次）
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行的状态，这意味着它可以由JVM调度并执行，这并不意为着线程会立即执行。run()方法是线程启动后要进行回调的方法。

20.转发（forward）和重定向（redirect）的区别（3次）
forward是容器中控制权的转向，是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取出来，然后再把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪里来的，所以它的地址栏里的地址还是原来的地址。
redirect是服务器根据逻辑，发送一个状态码，告诉浏览器重新去请求那个地址，因此可以在地址栏中看到跳转后的链接地址，redirect是无法访问到服务器保护起来的资源，但是可以从一个网站重定向到其他网站。forward更加高效，所以在满足条件的情况下尽量使用forward,并且这样也有助于隐藏实际的链接。在有些情况下，比如要访问你其他服务器上的资源，则必须使用重定向。

21.jsp的动态包含和静态包含有什么区别？（2次）
静态包含是通过jsp的include指令包含页面，动态包含是通过jsp标准动作<jsp:include>包含页面。
静态包含是编译时包含，如果包含的页面不存在则会产生编译错误，而且两个页面的“contentType”的属性应保持一致，因为两个页面会合二为一，只产生一个class文件，因此被包含页面发生改动在包含它的页面更新前不会得到更新。
动态包含是运行时包含，可以向被包含的页面传递参数，包含页面和被包含页面是独立的，会编译出两个class文件，如果被包含的页面不存在，不会产生编译错误，也不影响页面其他部分的执行。

22.RPC的原理（2次）
1）服务消费方（client）以本地调用方式调用服务；
2）client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
3）client stub找到服务地址，并将消息发送到服务端；
4）server stub收到消息后进行解码；
5）server stub根据解码结果调用本地的服务；
6）本地服务执行并将结果返回给server stub；
7）server stub将返回结果打包成消息并发送至消费方；
8）client stub接收到消息，并进行解码；
9）服务消费方得到最终结果。

23.JVM的原理（1次）
参见https://www.jianshu.com/p/28639d7a00fe

24.GC的原理，GC有哪几种算法？（2次）
参见https://www.jianshu.com/p/28639d7a00fe

25.数组有没有length()方法，String有没有length()方法？（1次）
数组没有length()方法，数组有length属性，String有length()方法。

26.注册中心为什么选Zookeeper而不选Redis?（1次）
Zookeeper的数据模型很简单，有一系列被称为ZNode的数据节点组成，Zookeeper将全部数据存储在内存中，支持集群，支持事件监听。这些特点决定了Zookeeper特别适合作为注册中心(数据发布/订阅)。

27.在java中如何跳出当前的多重嵌套循环？（2次）
在最外层前加一个标记A，然后用break A;可以跳出多重循环。

28.HashMap,LinkHashMap,HastTable,currentHashMap有什么区别（2次）
HashMap非线程安全，高效，支持null;
LinkHashMap是HashMap的子类，保存了记录的插入顺序；
HashTable:线程安全，低效，不支持null;
currentHashMap：线程安全,高效；

29.Redis 和 Memcached的区别（2次）
（1） Redis 与Memcached相比，比仅支持简单的key-value数据类型，同时还提供list,set,zset,string等数据结构的存储；
（2）Redis支持数据的备份，即master-slave模式的数据备份；
（3）Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用等等。

30.String、StringBuilder和StringBuffer的区别？（17次）
String是只读字符串，String引用的字符串内容是不能被改变的。
StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer要高。

31.Java 中会存在内存泄漏吗，请简单描述。 （2次）
理论上Java因为有垃圾回收机制不会存在内存泄露问题；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收，因此也会导致内存泄露的发生。例如Hibernate的一级缓存中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭或清空一级缓存就可能导致内存泄露。

32.ArrayList和LinkedList的区别（11次）
ArrayList 是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。
LinkedList使用双向链表实现存储（将内存中零散的内存单元通过附加的引用关联起来，形成一个可以按序号索引的线性结构，这种链式存储方式与数组的连续存储方式相比，内存的利用率更高），按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

33.java中的内存分配（7次）
（1）虚拟机栈
（2）本地方法栈
（3）堆
（4）方法区
（5）程序计数器

34.介绍一下Mycat（1次）
Mycat是一个可以用于MySQL读写分离和高可用的中间件，其前身是阿里的Cobar项目。

35.负载均衡原理及实现方式（1次）
	负载均衡就是用多台服务器组成服务器阵列，服务器之间是对称的，能够独立地为客户提供服务，它是对系统的横向扩展。采用负载均衡技术一方面能克服集中式服务器的单点故障，增强系统可用性，提高系统的吞吐量；另外一方面负载均衡能够以较高的性价比对系统进行升级。实现负载均衡的常见方式有下面几种：
1 HTTP重定向方式
	HTTP重定向在网页登陆时最常见，当用户输入账号密码，点击登陆后，服务器判断登陆信息是否正确，正确时跳转到操作界面，错误时跳转到失败界面。该方式利用HTTP协议实现负载均衡，它的原理是：客户端访问应用服务器时，应用服务器不返回响应内容，而是根据一定策略返回一个重定向指令（302 Moved Temporarily），客户端浏览器接到指令后，跳转到指令中指定的服务器地址。
2 DNS解析方式
	广域网中访问某主机，必须知道其IP地址，我们能够通过域名来访问它，是因为DNS服务自动解析出了域名所对应的IP地址。这种方式实现负载均衡的原理是为一个域名设置多个ip地址（多个A记录），当用户访问该域名时，域名服务器按顺序依次解析服务器的IP地址，将用户的访问分配到不同的服务器上，该机制的特点是实现简单，成本低。
3 反向代理方式
	正向代理方式是客户使用代理服务器访问多个Web 服务器，而反向代理方式是多个客户使用它访问内部Web服务器。它的原理是让反向代理服务器均匀地将用户请求分布在各个内部服务器中，从而达到负载均衡的目的，常见的有nginx。该方式可以根据内部服务器的性能差异和实时负载情况动态得进行负载均衡，以保证访问效率；代理服务器可以引入缓存机制，对服务器返回的资源进行缓存，降低原始服务器的负载；安全性方面，反向代理服务器屏蔽了用户对服务器的真实访问，也可以为不安全的连接建立安全的通道，以提供更高的安全保障。
4 LVS负载均衡
	LVS的全称是：Linux Virtual Server，Linux虚拟服务器，是由章文嵩博士发起的自由软件项目，目前LVS已经是Linux内核的一部分，它通过Linux系统和LVS来实现负载均衡。LVS由三个部分构成：一是Load Balancer层，由一个或多个调度器构成；二是Server Array层，由多个实际的服务器构成，比如WEB服务器、Mail服务器、视频服务器等等；三是Shared Storage层为所有Real Server提供共享存储空间和内容一致性的存储区域。
5 CDN
	Content Delivery Network，内容分发网络，它的原理是利用缓存、复制技术将数据分布在不同地理位置的服务器上，从而提高位于不同地方用户的访问速度。

35.你的项目中如何实现Session共享的？（1次）
在项目基础上加入Spring Session框架来实现Session统一存储在Redis中

36.项目中如何实现分布式事务的？（1次）
消息事务+最终一致性：消息事务就是基于消息中间件的两阶段提交，本质上是对消息中间件的一种特殊利用，它是将本地事务和发消息放在了一个分布式事务里，保证要么本地操作成功成功并且对外发消息成功，要么两者都失败。

37.如何防止表单重复提交？（3次）
1、禁用提交按钮
表单提交后使用 Javascript 使提交按钮disable。这种方法防止心急的用户多次点击按钮。但有个问题，如果客户端把 Javascript 给禁止掉，这种方法就无效了。
2、Post/Redirect/Get 模式
在提交后执行页面重定向，当用户提交了表单后，执行一个客户端的重定向，转到提交成功信息页面。这能避免用户按 F5 导致的重复提交，而其也不会出现浏览器表单重复提交的警告，也能消除按浏览器前进和后退按导致的同样问题。
 3、在 session 中存放一个特殊标志
当表单页面被请求时，生成一个特殊的字符标志串，存在 session 中，同时放在表单的隐藏域里。接受处理表单数据时，检查标识字串是否存在，并立即从 session 中删除它，然后正常处理数据。如果发现表单提交里没有有效的标志串，这说明表单已经被提交过了，忽略这次提交。
 4、使用Cookie处理
使用Cookie记录表单提交的状态，根据其状态可以检查是否已经提交表单。
 5、在数据库里添加约束
在数据库里添加唯一约束或创建唯一索引，防止出现重复数据。这是最有效的防止重复提交数据的方法。

38.重载（Overload）和重写（Override）的区别（5次）
方法的重载和重写都是实现多态的方式，区别在于重载实现的是编译时的多态性，而重写实现的是运行时的多态性。
重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；
重写发生在子类与父类之间，重写要求子类重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常。
重载对返回类型没有特殊的要求。

39.抽象类（abstract class）和接口（interface）的区别（10次）
1.抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。
2.一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。
3.接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。
4.抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。
5.抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。
6.有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

40.Error和Exception的区别（1次）
Error表示系统级的错误和程序不必处理的异常，是可能恢复但很困难的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；
Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；它表示如果程序运行正常，从不会发生的情况。

41.为什么集合类没有实现Cloneable和Serializable接口？（1次）
克隆或者是序列化的语义和含义是跟具体的实现相关的。因此，应该由集合类的具体实现来决定如何被克隆或者是序列化。

42.throw和throws的区别（1次）
区别一：throw 是语句抛出一个异常；throws 是方法抛出一个异常；
区别二：throws可以单独使用，但throw不能；
区别三：throw要么和try-catch-finally语句配套使用，要么与throws配套使用。但throws可以单独使用，然后再由处理异常的方法捕获。

43.char 型变量中能不能存贮一个中文汉字，为什么？（1次）
char类型可以存储一个中文汉字，因为Java中使用的编码是Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个char类型占2个字节（16比特），所以放一个中文是没问题的。

44.GC是什么？为什么要有GC？（2次）
GC是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显式操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() ，但JVM可以屏蔽掉显式的垃圾回收调用。 
垃圾回收可以有效的防止内存泄露，有效地使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。

45.try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被执行，什么时候被执行，在return前还是后? （1次）
会执行，在return前执行。

46.编写多线程程序有几种实现方式？（13次） 
一种是继承Thread类；一种是实现Runnable接口，一种是实现Callable接口。

47.get和post请求的区别？（5次）
①get请求用来从服务器上获得资源，而post是用来向服务器提交数据； 
②get将表单中数据按照name=value的形式，添加到action 所指向的URL 后面，并且两者使用"?"连接，而各个变量之间使用"&"连接；post是将表单中的数据放在HTTP协议的请求头或消息体中，传递到action所指向URL； 
③get传输的数据要受到URL长度限制（1024字节）；而post可以传输大量的数据，上传文件通常要使用post方式； 
④使用get时参数会显示在地址栏上，如果这些数据不是敏感数据，那么可以使用get；对于敏感数据还是应用使用post； 
⑤get使用MIME类型application/x-www-form-urlencoded的URL编码（也叫百分号编码）文本的格式传递参数，保证被传送的参数由遵循规范的文本组成.

48.Statement和PreparedStatement有什么区别？（1次）
①PreparedStatement接口代表预编译的语句，它主要的优势在于可以减少SQL的编译错误并增加SQL的安全性（减少SQL注射攻击的可能性）；
②PreparedStatement中的SQL语句是可以带参数的，避免了用字符串连接拼接SQL语句的麻烦和不安全；
③当批量处理SQL或频繁执行相同的查询时，PreparedStatement有明显的性能上的优势，由于数据库可以将编译优化后的SQL语句缓存起来，下次执行相同结构的语句时就会很快（不用再次编译和生成执行计划）。

49.怎样将GB2312编码的字符串转换为ISO-8859-1编码的字符串？ （1次）
String s1 = "你好";
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");

50.JSP有哪些内置对象？作用分别是什么？（1次）
JSP有9个内置对象： 
- request：封装客户端的请求，其中包含来自GET或POST请求的参数； 
- response：封装服务器对客户端的响应； 
- pageContext：通过该对象可以获取其他对象； 
- session：封装用户会话的对象； 
- application：封装服务器运行环境的对象； 
- out：输出服务器响应的输出流对象； 
- config：Web应用的配置对象； 
- page：JSP页面本身（相当于Java程序中的this）； 
- exception：封装页面抛出异常的对象。

51.面向对象的特征有哪些方面？ (3次)
继承、封装、多态。

52.为什么不能根据返回类型来区分重载？（1次）
在Java语言中，要重载一个方法，除了要与原方法具有相同的简单名称之外，还要求必须拥有一个与原方法不同的特征签名，特征签名就是一个方法中各个参数在常量池中的字段符号引用的集合，也就是因为返回值不会包含在特征签名之中，因此Java语言里面是无法仅仅依靠返回值的不同来对一个已有方法进行重载。

53.JSP和Servlet是什么关系？（1次）
Servlet是一个特殊的Java程序，它运行于服务器的JVM中，能够依靠服务器的支持向浏览器提供显示内容。JSP本质上是Servlet的一种简易形式，JSP会被服务器处理成一个类似于Servlet的Java程序，可以简化页面内容的生成。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet更侧重于控制逻辑，在MVC架构模式中，JSP适合充当视图而Servlet适合充当控制器。

54.是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？ （3次）
不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，在调用静态方法时可能对象并没有被初始化。

55.java中的四种引用（1次）
java对象的引用包括：强引用，软引用，弱引用，虚引用。
1.强引用：创建一个对象并把这个对象赋给一个引用变量；
2.软引用：如果一个对象具有软引用，内存空间足够，垃圾回收器就不会回收它；
3.弱引用：当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象；
4.虚引用：如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。

56. java创建对象的方式（3次）
1.使用new关键字；
2.使用Class类的newInstance方法；
3.使用Constructor类的newInstance方法；
4.使用clone方法
5.使用反序列化

57.用Java写一个单例类（5次）
public class Singleton {
    private Singleton(){}
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}

58.Spring的自动装配方式有哪些？（2次）
- no：不进行自动装配，手动设置Bean的依赖关系。  
- byName：根据Bean的名字进行自动装配。  
- byType：根据Bean的类型进行自动装配。  
- constructor：类似于byType，不过是应用于构造器的参数，如果正好有一个Bean与构造器的参数类型相同则可以自动装配，否则会导致错误。 
- autodetect：如果有默认的构造器，则通过constructor的方式进行自动装配，否则使用byType的方式进行自动装配。
说明：自动装配没有自定义装配方式那么精确，而且不能自动装配简单属性（基本类型、字符串等），在使用时应注意。

59.索引失效原因（7次）
1.查询条件包含or，可能导致索引失效；
2.如果字段类型是字符串，where时一定用引号括起来，否则索引失效；
3.like通配符可能导致索引失效；
4.联合索引，查询时的条件列不是联合索引中的第一个列，索引失效；
5.在索引列上使用mysql的内置函数，索引失效；
6.对索引列运算，索引失效；
7.索引字段上使用（！= 或者 < >，not in）时，可能会导致索引失效；
8.索引字段上使用is null， is not null，可能导致索引失效；
9.左连接查询或者右连接查询查询关联的字段编码格式不一样，可能导致索引失效

60.描述一下JVM加载class文件的原理机制（3次）
JVM中类的装载是由类加载器和它的子类来实现的，Java中的类加载器是一个重要的Java运行时系统组件，它负责在运行时查找和装入类文件中的类。 
由于Java的跨平台性，经过编译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时，JVM会确保这个类已经被加载、连接和初始化。类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备和解析三个步骤。最后JVM对类进行初始化，包括：1)如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；2)如果类中存在初始化语句，就依次执行这些初始化语句。 
类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器。从JDK 1.2开始，类加载过程采取了父亲委托机制。父亲委托机制更好的保证了Java平台的安全性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。

61.SQL的优化方法（15次）
1.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。		
2.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描。	
3.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。		
4.应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描。	
5.in 和 not in 也要慎用，否则会导致全表扫描。			
6.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描	
7.查询结果不要用*来查询所有字段，要明确指明查询字段；
8.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描；
9.建立索引时字段不能有null值；
10.根据查询条件，建立索引，如果查询条件不止一个，使用组合索引

62.SpringMVC与Struts2的区别（4次）
 1、Struts2是类级别的拦截， 一个类对应一个request上下文，SpringMVC是方法级别的拦截，   一个方法对应一个request上下文，而方法同时又跟一个url对应,所以说从架构本身上SpringMVC就容易实现RestfulURL,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url，   而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。
2、SpringMVC的方法之间基本上独立的，独享request、response数据，请求数据通过参数获取，  处理结果通过ModelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，  但其所有Action变量是共享的，这不会影响程序运行，却给我们编码 读程序时带来麻烦，每次来了请求就创建一个Action，一个Action对象对应一个request上下文。
3、Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。
4、拦截器实现机制上，Struts2有自己的interceptor机制，SpringMVC用的是独立的AOP方式，  这样导致Struts2的配置文件量还是比SpringMVC大。
5、SpringMVC的入口是servlet，Struts2是filter； 
6、SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，  而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。
7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。
8、SpringMVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（  当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。
9、设计思想上，Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。
10、SpringMVC开发效率和性能高于Struts2。

63.下面代码的运行结果（1次）
class Annoyance extends Exception {}
class Sneeze extends Annoyance {}

class Human {

    public static void main(String[] args) 
        throws Exception {
        try {
            try {
                throw new Sneeze();
            } 
            catch ( Annoyance a ) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        } 
        catch ( Sneeze s ) {
            System.out.println("Caught Sneeze");
            return ;
        }
        finally {
            System.out.println("Hello World!");
        }
    }
}

运行结果：
Caught Annoyance
Caught Sneeze
Hello World!

64.MySQL与Oracle的区别（6次）
(1) 对事务的提交
 MySQL默认是自动提交，而Oracle默认不自动提交，需要用户手动提交，
(2) 分页查询
 MySQL是直接在SQL语句中写"select... from ...where...limit  x, y",有limit就可以实现分页;而Oracle则是需要用到伪列ROWNUM和嵌套查询
(3) 事务隔离级别
MySQL是可重读的隔离级别，而Oracle是读已提交的隔离级别，同时二者都支持serializable串行化事务隔离级别，可以实现最高级别的读一致性。每个session提交后其他session才能看到提交的更改。Oracle通过在undo表空间中构造多版本数据块来实现读一致性，每个session查询时，如果对应的数据块发生变化，Oracle会在undo表空间中为这个session构造它查询时的旧的数据块MySQL没有类似Oracle的构造多版本数据块的机制，只支持read commited的隔离级别。一个session读取数据时，其他session不能更改数据，但可以在表最后插入数据。session更新数据时，要加上排它锁，其他session无法访问数据；
(4) 对事务的支持
 MySQL在innodb存储引擎的行级锁的情况下才可支持事务，而Oracle则完全支持事务；
(5) 保存数据的持久性
 MySQL是在数据库更新或者重启，则会丢失数据，Oracle把提交的sql操作线写入了在线联机日志文件中，保持到了磁盘上，可以随时恢复；
(6) 并发性
 MySQL以表级锁为主，对资源锁定的粒度很大，如果一个session对一个表加锁时间过长，会让其他session无法更新此表中的数据。 虽然InnoDB引擎的表可以用行级锁，但这个行级锁的机制依赖于表的索引，如果表没有索引，或者sql语句没有使用索引，那么仍然使用表级锁。
Oracle使用行级锁，对资源锁定的粒度要小很多，只是锁定sql需要的资源，并且加锁是在数据库中的数据行上，不依赖与索引。所以Oracle对并发性的支持要好很多。

65.Spring中Bean的作用域有哪些？（1次）
在Spring的早期版本中，仅有两个作用域：singleton和prototype，前者表示Bean以单例的方式存在；后者表示每次从容器中调用Bean时，都会返回一个新的实例。Spring 2.x中针对WebApplicationContext新增了3个作用域，分别是：request、session和globalSession。

66.访问修饰符public,private,protected以及不写（默认）时的区别？（1次）
类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。Java中，外部类的修饰符只能是public或默认，类的成员（包括内部类）的修饰符可以是以上四种。

67.java中==和equals()的区别（5次）
对于 == ：
作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
作用于引用类型的变量，则比较的是所指向的对象的地址；
对于 equals:
equals方法不能作用于基本数据类型的变量；
如果没有对Object中equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址，重写则比较的是内容

68.Redis的哨兵模式（2次）
https://www.jianshu.com/p/06ab9daf921d

69.两个对象值相同(x.equals(y) == true)，但却可有不同的hashcode，这句话对不对？（3次）
不对，如果两个对象x和y满足x.equals(y) == true，它们的哈希码（hash code）应当相同。Java对于eqauls方法和hashCode方法是这样规定的：(1)如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；(2)如果两个对象的hashCode相同，它们并不一定相同。

70.运行时异常与受检异常有何异同？（2次）
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误，只要程序设计得没有问题通常就不会发生。受检异常跟程序运行的上下文环境有关，即使程序设计无误，仍然可能因使用的问题而引发。Java编译器要求方法必须声明抛出可能发生的受检异常，但是并不要求必须声明抛出未被捕获的运行时异常。

71.Spring框架中Bean的生命周期（1次）
① Spring IoC容器找到关于Bean的定义并实例化该Bean。
② Spring IoC容器对Bean进行依赖注入。
③ 如果Bean实现了BeanNameAware接口，则将该Bean的id传给setBeanName方法。
④ 如果Bean实现了BeanFactoryAware接口，则将BeanFactory对象传给setBeanFactory方法。
⑤ 如果Bean实现了BeanPostProcessor接口，则调用其postProcessBeforeInitialization方法。
⑥ 如果Bean实现了InitializingBean接口，则调用其afterPropertySet方法。
⑦ 如果有和Bean关联的BeanPostProcessors对象，则这些对象的postProcessAfterInitialization方法被调用。
⑧ 当销毁Bean实例时，如果Bean实现了DisposableBean接口，则调用其destroy方法。

72.HashMap和Hashtable的区别（1次）
1.HashMap是非线程安全的，可以接受为null的键值(key)和值(value)，而Hashtable则不行。
2.Hashtable是线程安全的，多个线程可以共享一个Hashtable；
3.HashMap的迭代器是fail-fast迭代器，而Hashtable的enumerator迭代器。
4.由于Hashtable是线程安全的，所以在单线程环境下它比HashMap要慢。
5.HashMap不能保证随着时间的推移Map中的元素次序是不变的。

73.消息队列的应用场景（3次）
1.异步处理
2.应用解耦
3.流量削峰
4.消息通讯

74.BeanFactory 和 FactoryBean 的区别（1次）
1.BeanFactory是个Factory，也就是 IOC 容器或对象工厂，所有的 Bean 都是由 BeanFactory来进行管理。
2.FactoryBean是一个能生产或者修饰生成对象的工厂Bean，可以在BeanFactory中被管理，所以它并不是一个简单的Bean。当使用容器中factorybean的时候，该容器不会返回Factorybean本身，而是返回其生成的对象。要想获取FactoryBean的实现类本身，得在getBean(String BeanName)中的BeanName之前加上&,写成getBean(String &BeanName)。

75.Spring AOP与拦截器的区别（1次）
1. 拦截器只对action负责，作用层面一般位于Controller层；Spring AOP主要是拦截对Spring管理的Bean的访问，一般作用于Service层；
2、拦截器是链式的处理模式，这样有一个缺点就是，每次请求，都会访问action的上下文，不够灵活；Spring AOP的注解有@Before、@After、@AfterReturning、@AfterThrowing、@Around，可以更灵活的配置要监听处理的Bean。

76.spring boot的常用注解（7次）
1.@SpringBootApplication 
2.@SpringBootConfiguration
3.@SpringBootTest
4.@EnableAutoConfiguration

77.Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别?（3次）
sleep()方法是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复。
wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。

78.BIO、NIO、AIO的区别（2次）
BIO (Blocking I/O): 同步阻塞I/O模型，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。
NIO (New I/O): NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发
AIO (Asynchronous I/O): 异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。

79.注解的原理（1次）
注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。

80.索引的类型（7次）
1.普通索引
2.唯一索引
3.主键索引
4.组合索引
5.全文索引

81.dom4j和SAX的区别（1次）
DOM：要求解析器把整个XML文档装载到内存，并解析成一个Document对象。
优点：元素与元素之间保留结构关系，故可以进行增删改查操作。
缺点：XML文档过大，可能出现内存溢出。
SAX：逐行扫描文档，一边扫描一边解析，并以事件驱动的方式进行具体解析，每执行一行，都将触发对应的事件。
优点：处理速度快，可以处理大文件
缺点：只能读，逐行后将释放资源。

82.cookie和session的区别（4次）
1、存储位置不同
cookie的数据信息存放在客户端浏览器上。
session的数据信息存放在服务器上。
2、存储容量不同
单个cookie保存的数据<=4KB，一个站点最多保存20个Cookie。
对于session来说并没有上限，但出于对服务器端的性能考虑，session内不要存放过多的东西，并且设置session删除机制。
3、存储方式不同
cookie中只能保管ASCII字符串，并需要通过编码方式存储为Unicode字符或者二进制数据。
session中能够存储任何类型的数据。
4、隐私策略不同
cookie对客户端是可见的，别有用心的人可以分析存放在本地的cookie并进行cookie欺骗，所以它是不安全的。
session存储在服务器上，对客户端是透明对，不存在敏感信息泄漏的风险。
5、有效期上不同
开发可以通过设置cookie的属性，达到使cookie长期有效的效果。
session依赖于名为JSESSIONID的cookie，而cookie JSESSIONID的过期时间默认为-1，只需关闭窗口该session就会失效，因而session不能达到长期有效的效果。
6、服务器压力不同
cookie保管在客户端，不占用服务器资源。对于并发用户十分多的网站，cookie是很好的选择。
session是保管在服务器端的，每个用户都会产生一个session。假如并发访问的用户十分多，会产生十分多的session，耗费大量的内存。
7、浏览器支持不同
假如客户端浏览器不支持cookie：
cookie是需要客户端浏览器支持的，假如客户端禁用了cookie，或者不支持cookie，则会话跟踪会失效。
运用session需要使用URL地址重写的方式。一切用到session程序的URL都要进行URL地址重写，否则session会话跟踪还会失效。
假如客户端支持cookie：
cookie既能够设为本浏览器窗口以及子窗口内有效，也能够设为一切窗口内有效。
session只能在本窗口以及子窗口内有效。
8、跨域支持上不同
cookie支持跨域名访问。
session不支持跨域名访问。

83.mybatis和mybatis-plus的区别（6次）
Mybatis-Plus是一个Mybatis的增强工具，只是在Mybatis的基础上做了增强却不做改变，MyBatis-Plus支持所有Mybatis原生的特性，所以引入Mybatis-Plus不会对现有的Mybatis构架产生任何影响。
MyBatis-Plus 优点：
1、依赖少：仅仅依赖 Mybatis 以及 Mybatis-Spring 。
2、损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 。
3、预防SQL注入：内置 Sql 注入剥离器，有效预防Sql注入攻击 。
4、通用CRUD操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求 。
5、多种主键策略：支持多达4种主键策略（内含分布式唯一ID生成器），可自由配置，完美解决主键问题 。
6、支持热加载：Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动

84.线程池的种类（4次）
newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

85、选择使用Spring框架的原因（2次）
- 非侵入式：支持基于POJO的编程模式，不强制性的要求实现Spring框架中的接口或继承Spring框架中的类。
- IoC容器：IoC容器帮助应用程序管理对象以及对象之间的依赖关系，对象之间的依赖关系如果发生了改变只需要修改配置文件而不是修改代码，因为代码的修改可能意味着项目的重新构建和完整的回归测试。有了IoC容器，程序员再也不需要自己编写工厂、单例，这一点特别符合Spring的精神"不要重复的发明轮子"。
- AOP（面向切面编程）：将所有的横切关注功能封装到切面中，通过配置的方式将横切关注功能动态添加到目标代码上，进一步实现了业务逻辑和系统服务之间的分离。另一方面，有了AOP程序员可以省去很多自己写代理类的工作。
- MVC：Spring的MVC框架是非常优秀的，从各个方面都可以甩Struts 2几条街，为Web表示层提供了更好的解决方案。
- 事务管理：Spring以宽广的胸怀接纳多种持久层技术，并且为其提供了声明式的事务管理，在不需要任何一行代码的情况下就能够完成事务管理。

86.java8的新特性（2次）
Lambda 表达式 − Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。
方法引用 − 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。
新工具 − 新的编译工具，如：Nashorn引擎 jjs、 类依赖分析器jdeps。
Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。
Date Time API − 加强对日期与时间的处理。
Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。
Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。

87.垃圾回收的机制有哪些？（1次）
分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式

88.Collection和Collections的区别？（2次）
Collection是一个接口，它是Set、List等容器的父接口；
Collections是个一个工具类，提供了一系列的静态方法来辅助容器操作。

89.线程的状态都有哪些？（5次）
新建、就绪、运行、阻塞、死亡

90.Redis的集群方式（1次）
主从复制，哨兵模式、集群

91.UNION 和 UNION ALL 的区别（1次）
UNION 操作符选取不同的值。如果允许重复的值，使用 UNION ALL。

92.javascript中var和let的区别（1次）
var拥有全局作用域和函数作用域；
let拥有全局作用域、函数作用域及块作用域。

93.抽象类的作用（1次）
抽象类是用来捕捉子类的通用特性的，是被用来创建继承层级里子类的模板。

94.redis缓存雪崩，缓存穿透，缓存击穿的解决方法(5次)
https://zhuanlan.zhihu.com/p/100706208

95.SQL的执行顺序(2次)
1.from 
2.join 
3.on 
4.where 
5.group by
6.avg,sum.... 
7.having 
8.select 
9.distinct 
10.order by
11.limit 

96.什么是SQL注入，如何防止SQL注入?(3次)
SQL注入是程序对用户输入数据的合法性没有判断和处理，导致攻击者可以在 Web 应用程序中事先定义好的 SQL 语句中添加额外的 SQL 语句，在管理员不知情的情况下实现非法操作，以此来实现欺骗数据库服务器执行非授权的任意查询，从而进一步获取到数据信息。
防止SQL注入：
1.采用预编译技术;
2.严格控制数据类型;
3.对特殊的字符进行转义;

97.synchronized 和java.util.concurrent.locks.Lock的区别(2次)
Lock是Java 5以后引入的新的API，和关键字synchronized相比
相同点：Lock 能完成synchronized所实现的所有功能；
不同点：Lock有比synchronized更精确的线程语义和更好的性能，而且不强制性的要求一定要获得锁。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且最好在finally 块中释放。

98.Mybatis的一级缓存和二级缓存(2次)
http://c.biancheng.net/mybatis/cache.html

99.nginx的正向代理和反向代理的区别(1次)
https://www.php.cn/nginx/422609.html

100.Java有没有goto？(1次)
goto 是Java中的保留字，在目前版本的Java中没有使用。

101.Java 中的final关键字有哪些用法？(3次)
(1)修饰类：表示该类不能被继承；
(2)修饰方法：表示方法不能被重写；
(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

102.mysql索引的数据结构（1次）
B+树

103.线程的sleep()方法和yield()方法有什么区别？(1次)
① sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
② 线程执行sleep()方法后转入阻塞（blocked）状态，而执行yield()方法后转入就绪（ready）状态；
③ sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常；
④ sleep()方法比yield()方法（跟操作系统CPU调度相关）具有更好的可移植性。

104.final、finally、finalize的区别（1次）
final：修饰符（关键字）有三种用法：如果一个类被声明为final，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词。将变量声明为final，可以保证它们在使用中不被改变，被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。被声明为final的方法也同样只能使用，不能在子类中被重写。
finally：通常放在try…catch…的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在finally块中。
finalize：Object类中定义的方法，Java中允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize()方法可以整理系统资源或者执行其他清理工作。

105.springboot如何实现热部署？（1次）
1.模板热部署
2.使用调试模式Debug实现热部署
3.spring-boot-devtools
4.Spring Loaded
5.JRebel

106.Linux查看系统负载的命令（1次）
1.top
2.uptime
3.w
4.vmstat

107.如何在 Spring Boot 启动的时候运行一些特定的代码？（1次）
可以实现接口 ApplicationRunner 或者 CommandLineRunner，这两个接口实现方式一样，它们都只提供了一个 run 方法。

108.nginx如何实现高并发的？（1次）
异步，非阻塞，使用了epoll 和大量的底层代码优化。