java基础面试题

刚刚参加完面试，问了一堆java基础，记录整理一下，方便日后复习，也欢迎其他准备面试的同学自取

http常用的状态码

200：请求被正常处理
204：请求被受理但没有资源可以返回
206：客户端只是请求资源的一部分，服务器只对请求的部分资源执行GET方法
301：永久性重定向
302：临时重定向
303：与302状态码有相似功能，只是它希望客户端再请求一个URI的时候，能通过GET方法重定向到另一个URI上
304：发送附带条件的请求时，条件不满足时返回，与重定向无关
307：临时重定向，与302类似，只是强制要求使用POST方法
400：请求报文语法有误，服务器无法识别
401：请求需要认证
403：请求的对应资源被访问
404：服务器无法找到对应资源
500：服务器内部错误
503：服务器正忙

数据库索引的作用

数据库索引是对数据库表中一列或多列的值进行排序的一种结构，使用索引可快速访问数据库表中的特定信息。索引的主要目的是加快检索表中数据的方法。

数据库索引索引可以加快数据的检索速度，加速表和表之间的连接，减少查询中分组和排序的时间。 在查询的过程中，使用优化隐藏器，提高系统的性能。

数据库索引类型有普通索引、组合索引、唯一索引、全文索引、主键索引

数据库索引的优缺点

优点

第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二，可以大大加快 数据的检索速度，这也是创建索引的最主要的原因。
第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四，在使用分组和排序 子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。

缺点

第一，创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
第二，索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
第三，当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

数据库索引的使用场景

在经常需要搜索的列上，可以加快搜索的速度；
在作为主键的列上，强制该列的唯一性和组织表中数据的排列结构；
在经常用在连接的列上，这 些列主要是一些外键，可以加快连接的速度；
在经常需要根据范围进行搜索的列上创建索引，因为索引已经排序，其指定的范围是连续的；
在经常需要排序的列上创 建索引，因为索引已经排序，这样查询可以利用索引的排序，加快排序查询时间；
在经常使用在WHERE子句中的列上面创建索引，加快条件的判断速度。

什么情况下不应该创建索引

第一，对于那些在查询中很少使用或者参考的列不应该创建索引。这是因 为，既然这些列很少使用到，因此有索引或者无索引，并不能提高查询速度。相反，由于增加了索引，反而降低了系统的维护速度和增大了空间需求。
第二，对于那 些只有很少数据值的列也不应该增加索引。这是因为，由于这些列的取值很少，例如人事表的性别列，在查询的结果中，结果集的数据行占了表中数据行的很大比例，即需要在表中搜索的数据行的比例很大。增加索引，并不能明显加快检索速度。
第三，对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为，这些列的数据量要么相当大，要么取值很少。
第四，当修改性能远远大于检索性能时，不应该创建索 引。这是因为，修改性能和检索性能是互相矛盾的。当增加索引时，会提高检索性能，但是会降低修改性能。当减少索引时，会提高修改性能，降低检索性能。因 此，当修改性能远远大于检索性能时，不应该创建索引。

索引失效

1.单独引用复合索引里非第一位置的索引列
2.对索引列运算，运算包括（+、-、*、/、！、<>、%、like’%_’（%放在前面）、or、in、exist等），导致索引失效。
3.对索引应用内部函数，这种情况下应该建立基于函数的索引。
4、类型错误，如字段类型为varchar，where条件用number。
5.如果MySQL预计使用全表扫描要比使用索引快，则不使用索引
6.like的模糊查询以%开头，索引失效
7.索引列没有限制 not null，索引不存储空值，如果不限制索引列是not null，oracle会认为索引列有可能存在空值，所以不会按照索引计算

联合索引注意事项（最左前缀原则）

在MySQL建立联合索引时会遵守最左前缀匹配原则，即最左优先，在检索数据时从联合索引的最左边开始匹配。

数据库事务

脏读：脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。
不可重复读：是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。
幻读：是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

	脏读	不可重复读	幻读
读未提交	√	√	√
读已提交	×	√	√
可重复读	×	×	√
串行化	×	×	×

几种常用数据库的默认隔离级别

mysql默认的事务处理级别是可重复读。
Oracle默认系统事务隔离级别是读已提交。
SQL Server默认系统事务隔离级别是读已提交

三大范式

第一范式（1NF）：要求数据库表的每一列都是不可分割的原子数据项。
第二范式（2NF）：在1NF的基础上，非码属性必须完全依赖于候选码（在1NF基础上消除非主属性对主码的部分函数依赖）
第三范式（3NF）：在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）

表的冗余字段

什么是冗余字段

在设计数据库时，某一字段属于一个表，但他又出现在另外一个或多个表，且完全等同于它在其本来所属表的意义表达，那么这个字段就是一个冗余字段

冗余字段的使用场景

如果一个字段修改次数非常少，基本可以忽略不记，并且这个字段冗余之后，可以大大的减少工作量，提高工作效率，那这个字段就可以冗余。
反之如果一个字段经常修改，并且实时记录，那最好不要冗余，否则会带来很多不必要的操作，不停的更新数据。
总而言之，冗余字段是否存在，根本根据是是否可以提高数据库效率，工作效率，如果在满足条件的情况下，冗余字段是可以出现的。

常见的加密算法

MD5算法

MD5 用的是哈希函数，它的典型应用是对一段信息产生信息摘要，以防止被篡改。严格来说，MD5 不是一种加密算法 而是摘要算法。无论是多长的输入，MD5 都会输出长度为128bits 的一个串 (通常用16 进制表示为 32 个字符)。

SHA1算法

SHA1是和MD5 一样流行的消息摘要算法，然而SHA1比MD5的安全性更强。对于长度小于 2 ^ 64 位的消息，SHA1会产生一个160位的消息摘要。基于MD5、SHA1的信息摘要特性以及不可逆 (一般而言)，可以被应用在检查文件完整性以及数字签名等场景。

HMAC算法

HMAC 是密钥相关的哈希运算消息认证码（Hash-based Message Authentication Code），HMAC 运算利用哈希算法 (MD5、SHA1 等)，以一个密钥和一个消息为输入，生成一个消息摘要作为输出。
HMAC发送方和接收方都有的key进行计算，而没有这把 key 的第三方，则是无法计算出正确的散列值的，这样就可以防止数据被篡改。

DES算法

DES 加密算法是一种分组密码，以 64 位为分组对数据加密，它的密钥长度是56位，加密解密用同一算法。
DES 加密算法是对密钥进行保密，而公开算法，包括加密和解密算法。这样，只有掌握了和发送方相同密钥的人才能解读由DES加密算法加密的密文数据。因此，破译DES加密算法实际上就是搜索密钥的编码。对于 56 位长度的密钥来说，如果用穷举法来进行搜索的话，其运算次数为2 ^ 56 次。

SM4算法

2006年我国公布了无限局域网产品使用的SM4密码算法。这是我国第一次公布自己的商用密码算法。

国际的DES算法和国产的SM4算法的目的都是为了加密保护静态储存和传输信道中的数据，主要特性如下：

	DES算法	SM4算法
计算基础	二进制	二进制
算法结构	使用标准的算术和逻辑运算、先代替后 置换，不含非线性变换	基本轮函数加迭代、含非线性变换
加解密算法是否相同	是	是
计算轮数	16轮（3des为16轮*3）	32轮
分组长度	64位	128位
秘钥长度	64位（3DES为128位）	128位
有效秘钥长度	56位（3des位112位）	128位
实现难度	易于实现	易于实现
实现性能	软件实现慢、硬件实现快	软件实现和硬件实现都快
安全性	较低（3des较高）	算法比较新，还未经过现实校验
分析：算法上看，国产SM4算法在计算过程中增加非线性变换，理论上能大大提高其算法的安全性，并且由专业机构进行了密码分析，民间也对21轮SM4进行了差分密码分析，结论均为安全性较高。

3DES算法

是基于DES的对称算法，对一块数据用 三个不同的密钥进行三次加密，强度更高。

AES算法

AES 加密算法是密码学中的高级加密标准，该加密算法采用对称分组密码体制，密钥长度的最少支持为128 位、192 位、256 位，分组长度 128 位，算法应易于各种硬件和软件实现。这种加密算法是美国联邦政府采用的区块加密标准。
AES本身就是为了取代DES 的，AES具有更好的安全性、效率和灵活性。

RSA算法

RSA 加密算法是目前最有影响力的公钥加密算法，并且被普遍认为是目前最优秀的公钥方案之一。RSA 是第一个能同时用于加密和数字签名的算法，它能够抵抗到目前为止已知的所有密码攻击，已被 ISO 推荐为公钥数据加密标准。
RSA 加密算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

SM2算法

SM2算法由国家密码管理局于2010年12月17日发布，全称为椭圆曲线算法。
椭圆曲线并不是椭圆，之所以称为椭圆曲线是因为它们是用三次方程来表示的，并且该方程与计算椭圆周长的方程相似。一般而言，椭圆曲线的三次方程形为：

[其中a,b,c,d和e是满足某些条件的实数，因为方程中的指数最高是3，所以我们称之为三次方程，或者说方程的次数为3]

SM2算法使用的方程为：y^2= x^3 + ax + b

SM2算法实现如下：

• 选择Ep(a,b)的元素G,使得G的阶n是一个大素数
• G的阶是指满足nG=O的最小n值
• 秘密选择整数k，计算B=kG，然后公开(p,a,b,G,B)，B为公钥，保密k，k为私钥

加密M：
先把消息M变换成为Ep(a,b)中一个点Pm，然后，选择随机数r，计算密文Cm={rG,Pm+rP)，如果r使得rG或者rP为O，则要重新选择r。

解密Cm:
(Pm+rP)-k(rG)=Pm+rkG-krG=Pm

SM2算法的安全性基于一个数学难题”离散对数问题ECDLP”实现，即考虑等式Q=KP，其中Q、P属于Ep(a,b)，K<p，则：1) p=“” 已知q和p，计算k，是困难的。<=“”>

现今对椭圆曲线研究的时间短，经过许多优秀的数学家的努力，至今一直没有找到亚指数级算法。正是由于目前所知求解ECDLP的最好方法是指数级的，这使得我们选用SM2算法作加解密及数字签名时，所要求的密钥长度比RSA要短得多。

国际的RSA算法和国产的SM2算法的主要特性对比如下：

	RSA算法	SM2算法
计算结构	基于特殊的可逆模幂运算	基于椭圆曲线
计算复杂度	亚指数级	完全指数级
相同的安全性能下所需要的公钥位数	较多	较少（160位的SM2与1024位的RSA具有相同的安全等级）
密钥生成速度	慢	较RSA算法快百倍以上
解密加密速度	一般	较快
安全性	基于分解大整数的难度	基于离散对数问题、fcdlp数学难题

ECC算法

ECC 也是一种非对称加密算法，主要优势是在某些情况下，它比其他的方法使用更小的密钥，比如RSA 加密算法，提供相当的或更高等级的安全级别。不过一个缺点是加密和解密操作的实现比其他机制时间长(相比 RSA 算法，该算法对 CPU 消耗严重)。

SM3算法

摘要函数在密码学中具有重要的地位,被广泛应用在数字签名,消息认证,数据完整性检测等领域。摘要函数通常被认为需要满足三个基本特性：碰撞稳固性,原根稳固性和第二原根稳固性。

2005年,Wang等人给出了MD5算法和SHA-1算法的碰撞攻击方法，现今被广泛应用的MD5算法和SHA-1算法不再是安全的算法。

SM3密码摘要算法是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准。SM3算法适用于商用密码应用中的数字签名和验证，是在SHA-256基础上改进实现的一种算法。SM3算法采用Merkle-Damgard结构，消息分组长度为512位，摘要值长度为256位。

现今为止，SM3算法的安全性相对较高。

对称加密算法和非对称加密算法的区别

对称加密

分组密码就是将明文数据按固定长度进行分组，然后在同一密钥控制下逐组进行加密，从而将各个明文分组变换成一个等长的密文分组的密码。其中二进制明文分组的长度称为该分组密码的分组规模。
分组密码的实现原则如下：
（1） 必须实现起来比较简单,知道密钥时加密和脱密都十分容易,适合硬件和(或)软件实现.
（2） 加脱密速度和所消耗的资源和成本较低,能满足具体应用范围的需要.
分组密码的设计基本遵循混淆原则和扩散原则。
（1）混淆原则就是将密文、明文、密钥三者之间的统计关系和代数关系变得尽可能复杂，使得敌手即使获得了密文和明文，也无法求出密钥的任何信息;即使获得了密文和明文的统计规律，也无法求出明文的任何信息。
（2）扩散原则就是应将明文的统计规律和结构规律散射到相当长的一段统计中去。也就是说让明文中的每一位影响密文中的尽可能多的位，或者说让密文中的每一位都受到明文中的尽可能多位的影响。

对称加密算法是应用较早的加密算法，又称为共享密钥加密算法。在对称加密算法中，使用的密钥只有一个，发送和接收双方都使用这个密钥对数据进行加密和解密。这就要求加密和解密方事先都必须知道加密的密钥。
数据加密过程：在对称加密算法中，数据发送方将明文 (原始数据) 和加密密钥一起经过特殊加密处理，生成复杂的加密密文进行发送。
数据解密过程：数据接收方收到密文后，若想读取原数据，则需要使用加密使用的密钥及相同算法的逆算法对加密的密文进行解密，才能使其恢复成可读明文。

密钥管理：比较难，不适合互联网，一般用于内部系统
安全性：中
加密速度：快好几个数量级 (软件加解密速度至少快100 倍，每秒可以加解密数M比数据)，适合大数据量的加解密处理

非对称加密

公钥密码学与其他密码学完全不同, 使用这种方法的加密系统，不仅公开加密算法本身，也公开了加密用的密钥。
公钥密码系统与只使用一个密钥的对称传统密码不同，算法是基于数学函数而不是基于替换和置换。公钥密码学是非对称的，它使用两个独立的密钥，即密钥分为公钥和私钥，因此称双密钥体制。双钥体制的公钥可以公开，因此称为公钥算法。
公钥算法的出现，给密码的发展开辟了新的方向。公钥算法虽然已经历了20多年的发展，但仍具有强劲的发展势头，在鉴别系统和密钥交换等安全技术领域起着关键的作用
公钥算法的加密与解密由不同的密钥完成，并且从加密密钥得到解密密钥在计算上是不可行的。通常，公钥算法的两个密钥中任何一个都可以作为加密而另一个用作解密，但不是所有的公钥算法都是如此。

非对称加密算法，又称为公开密钥加密算法。它需要两个密钥，一个称为公开密钥 (public key)，即公钥，另一个称为私有密钥 (private key)，即私钥。
因为加密和解密使用的是两个不同的密钥，所以这种算法称为非对称加密算法。
如果使用公钥对数据进行加密，只有用对应的私钥才能进行解密。
如果使用私钥对数据进行加密，只有用对应的公钥才能进行解密。

密钥管理：密钥容易管理
安全性：高
加密速度：比较慢，适合 小数据量 加解密或数据签名

https怎么实现通信加密

(1)客户端发在通过TCP和服务器建立连接之后(443端口），发出一个请求证书的消息给服务器，在该请求里包含自己可实现的算法列表和其他需要的消息

(2)证书返回: 服务器端在收到消息后回应客户端并返回证书，在证书里包含了服务器信息、域名、申请证书的公司，公钥、数据加密算法等

(3) 证书验证: 客户端在收到证书后，判断证书签发机构是否正确，并使用该签发机构的公钥确认签名是否有效，客户端还会确保在证书中列出的域名就是它正在连接的域名。如果客户端确认证书有效，则生成对称加密密钥，并使用公钥将对称密钥加密。

(4) 密钥交换: 客户端将加密后的对称密钥发送给服务器，服务器在接收到对称密钥后使用私钥解密。

(5) 数据传输: 经过上述步骤， 客户端和服务器就完成了密钥对的交换，在之后的数据传输过程中，客户端和服务端就可以基于对称加密(加密和解密使用相同密钥的加密算法) 对数据加密后在网络上传输，保证了网络数据传输的安全性。

restful是什么

RESTFUL是一种网络应用程序的设计风格和开发方式，基于HTTP，可以使用XML格式定义或JSON格式定义。RESTFUL适用于移动互联网厂商作为业务接口的场景，实现第三方OTT调用移动网络资源的功能，动作类型为新增、变更、删除所调用资源。

RESTFUL特点包括：
1、每一个URI代表1种资源；
2、客户端使用GET、POST、PUT、DELETE4个表示操作方式的动词对服务端资源进行操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源；
3、通过操作资源的表现形式来操作资源；
4、资源的表现形式是XML或者HTML；
5、客户端与服务端之间的交互在请求之间是无状态的，从客户端到服务端的每个请求都必须包含理解请求所必需的信息。

前后端的跨域问题

什么是跨域

出于浏览器的同源策略限制。同源策略（Sameoriginpolicy）是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能都会受到影响。可以说Web是构建在同源策略基础之上的，浏览器只是针对同源策略的一种实现。同源策略会阻止一个域的javascript脚本和另外一个域的内容进行交互。所谓同源（即指在同一个域）就是两个页面具有相同的协议（protocol），主机（host）和端口号（port）

请求同域资源：

在域名 （或 ip 地址）相同，端口号相同下的请求资源，可以看做是同域资源

请求跨域资源：

请求的资源只要 是 域名（或 ip 地址）、端口号中任意一个不同的资源都可以认为是跨域资源

如：

• 端口号不同

• 127.0.0.1:80 与 127.0.0.1:8888 属于跨域

• 域名 (或 ip 地址) 不同

• 127.0.0.1:80 与 www.baidu.com:80 属于跨域

前后端分离项目中的跨域问题

例如：

前端 vue项目： 127.0.0.1:70

后端 SpringBoot项目： 127.0.0.1:8888

我们在前端 vue 项目中存放页面，页面中的数据是通过 axios 发起异步请求从 后端 SpringBoot项目中获取的

因此当我们访问前端页面时候， 我们可以理解为所在的当前所在 127.0.0.1:70 域上，所以访问这个127.0.0.1:70 域 的资源都是OK的，但如果使用 js 的方法访问其他域的资源时 就会出现跨域问题

拿 验证码 举例：
浏览器输入 127.0.0.1:70 访问登录资源，调用获取验证码方法 ( 发起axios 请求 127.0.0.1:8888 )
此时就会出现跨域的问题

怎么解决跨域问题

方法一：SpringBoot后端进行处理

在每个 Controller 类上加入 @CrossOrigin 注解
或者
在 Controller的基类中加上 @CrossOrigin 注解然后其他 Controller 类就有了这个 @Controller
此时跨域访问就不会报错了。

方法二：在Vue前端进行处理

浏览器 在同一个页面访问不同的域 是存在跨域问题的
但 服务器之间的访问是 没有跨域问题
因此 需要在前端设置代理， 通过代理访问 SpringBoot后端API

安装代理

cnpm install --save-dev http-proxy-middleware

配置请求 baseURL

在 src / utils / request.js 中

// 创建axios实例
const service = axios.create({
  // axios中请求配置有baseURL选项，表示请求URL公共部分
  // baseURL: 'http://127.0.0.1:8888/ruoyi',
  baseURL: '/api',
  // changeOrigin: true,
  // 超时
  timeout: 10000
})

配置 proxy

在 vue.config.js 中

module.exports = {
  devServer: {
    // 自动打开浏览器
    open: true,
    port: 70,
    proxy: {
      // // detail: https://cli.vuejs.org/config/#devserver-proxy
      '/api': {
        target: `http://localhost:8888/ruoyi`,
        changeOrigin: true,
        pathRewrite: {
          '^/api': ''
        }
      }
    }
  }
}

login.vue 页面发送验证码的请求

请求 API

import request from '@/utils/request'
// 获取验证码
export function getCodeImg() {
  return request({
    url: '/captcha/captchaImage?type=math',
    method: 'get'
  })
}

总结

跨域解决方案有很多种，如

• 使用 nginx代理
• 使用 filter 添加头信息
• 使用 @CrossOrigin 注解
• 使用 proxy 代理

@CrossOrigin 注解解决方案的优缺点:

优点 :

• 使用起来简单，直接在Controller类上加 @CrossOrigin 注解即可

缺点:

• 如果后端技术使用的不是 SpringBoot，后端代码还需要处理跨域问题
• 浏览器直接访问 后端API，在某种程度上是不太安全的

proxy 解决跨域问题优缺点

优点：

• 在浏览器中屏蔽了实际访问后端的 地址，相对安全
• 后端代码不必要进行额外处理跨域

缺点：

• 在浏览器中看不到后端访问的地址，开发阶段调试不太方便

http默认端口

80

https默认端口

443

tcp三次握手

第一次握手

客户端给服务器发送一个SYN段(在 TCP 标头中 SYN 位字段为 1 的 TCP/IP 数据包), 该段中也包含客户端的初始序列号(Sequence number = J)。

SYN是同步的缩写，SYN 段是发送到另一台计算机的 TCP 数据包，请求在它们之间建立连接

第二次握手

服务器返回客户端 SYN +ACK 段(在 TCP 标头中SYN和ACK位字段都为 1 的 TCP/IP 数据包)， 该段中包含服务器的初始序列号(Sequence number = K)；同时使 Acknowledgment number = J + 1来表示确认已收到客户端的 SYN段(Sequence number = J)。

ACK 是“确认”的缩写。 ACK 数据包是任何确认收到一条消息或一系列数据包的 TCP 数据包

第三次握手

客户端给服务器响应一个ACK段(在 TCP 标头中 ACK 位字段为 1 的 TCP/IP 数据包), 该段中使 Acknowledgment number = K + 1来表示确认已收到服务器的 SYN段(Sequence number = K)。

http怎么传输数据压缩

第一步:浏览器发送Http request 给Web服务器, request 中有Accept-Encoding: gzip, deflate。 (告诉服务器， 浏览器支持gzip压缩)

第二步:Web服务器接到request后， 生成原始的Response, 其中有原始的Content-Type和Content-Length。

第三步:Web服务器通过Gzip，来对Response进行编码， 编码后header中有Content-Type和Content-Length(压缩后的大小)， 并且增加了Content-Encoding:gzip. 然后把Response发送给浏览器.

第四步:浏览器接到Response后，根据Content-Encoding:gzip来对Response 进行解码。 获取到原始response后， 然后显示出网页.

有哪几种排序算法

冒泡排序

最简单的一种排序算法。假设长度为n的数组arr，要按照从小到大排序。则冒泡排序的具体过程可以描述为：首先从数组的第一个元素开始到数组最后一个元素为止，对数组中相邻的两个元素进行比较，如果位于数组左端的元素大于数组右端的元素，则交换这两个元素在数组中的位置。这样操作后数组最右端的元素即为该数组中所有元素的最大值。接着对该数组除最右端的n-1个元素进行同样的操作，再接着对剩下的n-2个元素做同样的操作，直到整个数组有序排列。算法的时间复杂度为O(n^2)。

选择排序

严蔚敏版《数据结构》中对选择排序的基本思想描述为：每一趟在n-i+1(i=1,2,…,n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。具体来说，假设长度为n的数组arr，要按照从小到大排序，那么先从n个数字中找到最小值min1，如果最小值min1的位置不在数组的最左端(也就是min1不等于arr[0])，则将最小值min1和arr[0]交换，接着在剩下的n-1个数字中找到最小值min2，如果最小值min2不等于arr[1]，则交换这两个数字，依次类推，直到数组arr有序排列。算法的时间复杂度为O(n^2)。

插入排序

插入排序的基本思想就是将无序序列插入到有序序列中。例如要将数组arr=[4,2,8,0,5,1]排序，可以将4看做是一个有序序列(图中用蓝色标出)，将[2,8,0,5,1]看做一个无序序列。无序序列中2比4小，于是将2插入到4的左边，此时有序序列变成了[2,4]，无序序列变成了[8,0,5,1]。无序序列中8比4大，于是将8插入到4的右边，有序序列变成了[2,4,8],无序序列变成了[0,5,1]。以此类推，最终数组按照从小到大排序。该算法的时间复杂度为O(n^2)。

希尔排序

希尔排序(Shell’s Sort)在插入排序算法的基础上进行了改进，算法的时间复杂度与前面几种算法相比有较大的改进。其算法的基本思想是：先将待排记录序列分割成为若干子序列分别进行插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行一次直接插入排序。

快速排序

快速排序的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，已达到整个序列有序。一趟快速排序的具体过程可描述为：从待排序列中任意选取一个记录(通常选取第一个记录)作为基准值，然后将记录中关键字比它小的记录都安置在它的位置之前，将记录中关键字比它大的记录都安置在它的位置之后。这样，以该基准值为分界线，将待排序列分成的两个子序列。

一趟快速排序的具体做法为：设置两个指针low和high分别指向待排序列的开始和结尾，记录下基准值baseval(待排序列的第一个记录)，然后先从high所指的位置向前搜索直到找到一个小于baseval的记录并互相交换，接着从low所指向的位置向后搜索直到找到一个大于baseval的记录并互相交换，重复这两个步骤直到low=high为止。

归并排序

“归并”的含义是将两个或两个以上的有序序列组合成一个新的有序表。假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]（[x]表示不小于x的最小整数）个长度为2(或者是1)的有序子序列，再两两归并。如此重复，直到得到一个长度为n的有序序列为止。这种排序方法称为2-路归并排序。

堆排序

堆的定义如下: n个元素的序列{k1, k2, … , kn}当且仅当满足一下条件时，称之为堆。

可以将堆看做是一个完全二叉树。并且，每个结点的值都大于等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于等于其左右孩子结点的值，称为小顶堆。

堆排序(Heap Sort)是利用堆进行排序的方法。其基本思想为：将待排序列构造成一个大顶堆(或小顶堆)，整个序列的最大值(或最小值)就是堆顶的根结点，将根节点的值和堆数组的末尾元素交换，此时末尾元素就是最大值(或最小值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次大值(或次小值)，如此反复执行，最终得到一个有序序列。

什么是时间复杂度

在计算机科学中，时间复杂性，又称时间复杂度，算法的时间复杂度是一个函数，它定性描述该算法的运行时间。这是一个代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是渐近的，亦即考察输入值大小趋近无穷时的情况。

#{}和${}的区别

#{}是占位符，会进行预编译，${}是占位符，会进行字符串替换

${}的使用场景

模糊查询（like %${xxx}%）

怎么解决循环依赖

循环依赖是什么？

Bean A 依赖 B，Bean B 依赖 A这种情况下出现循环依赖。
Bean A → Bean B → Bean A
更复杂的间接依赖造成的循环依赖如下。
Bean A → Bean B → Bean C → Bean D → Bean E → Bean A

循环依赖会产生什么结果？

当Spring正在加载所有Bean时，Spring尝试以能正常创建Bean的顺序去创建Bean。
例如，有如下依赖:
Bean A → Bean B → Bean C
Spring先创建beanC，接着创建bean B（将C注入B中)，最后创建bean A(将B注入A中)。

但当存在循环依赖时，Spring将无法决定先创建哪个bean。这种情况下，Spring将产生异常BeanCurrentlyInCreationException。

普通注入之间的循环依赖

比如：我现在有一个ServiceA需要调用ServiceB的方法，那么ServiceA就依赖于ServiceB，那在ServiceB中再调用ServiceA的方法，就形成了循环依赖。Spring在初始化bean的时候就不知道先初始化哪个，bean就会报错。

public class ClassA {

@Autowired
 
ClassB classB;
 
}
 
public class ClassB {
 
@Autowired
 
ClassA classA
 
}

如何解决循环依赖，最好的方法是重构代码，进行解耦，如果没有时间重构，可以使用下面的方法：

在你的配置文件中，在互相依赖的两个bean的任意一个加上lazy-init属性

<bean id="ServiceDependent1" class="org.xyz.ServiceDependent1" lazy-init="true"> 
 
<constructor-arg ref="Service"/> </bean>  
 
<bean id="ServiceDependent2" class="org.xyz.ServiceDependent2" lazy-init="true"> 
 
<constructor-arg ref="Service"/> </bean>   

在你注入bean时，在互相依赖的两个bean上加上@Lazy注解也可以

@Autowired     
 
@Lazy      
 
private ClassA classA; 
 
 
@Autowired 
 
@Lazy      
 
private ClassB classB; 

构造器注入循环依赖实例

首先定义两个相互通过构造器注入依赖的bean。

@Component
public class CircularDependencyA {
 
    private CircularDependencyB circB;
 
    @Autowired
    public CircularDependencyA(CircularDependencyB circB) {
        this.circB = circB;
    }
}

@Component
public class CircularDependencyB {
 
    private CircularDependencyA circA;
 
    @Autowired
    public CircularDependencyB(CircularDependencyA circA) {
        this.circA = circA;
    }
}

@Configuration
@ComponentScan(basePackages = { "com.baeldung.circulardependency" })
public class TestConfig {
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyTest {
 
    @Test
    public void givenCircularDependency_whenConstructorInjection_thenItFails() {
        // Empty test; we just want the context to load
    }
}

运行方法givenCircularDependency_whenConstructorInjection_thenItFails将会产生异常：BeanCurrentlyInCreationException: Error creating bean with name ‘circularDependencyA’:
Requested bean is currently in creation: Is there an unresolvable circular reference?

如何解决

重新设计

重新设计结构，消除循环依赖。

使用注解 @Lazy

一种最简单的消除循环依赖的方式是通过延迟加载。在注入依赖时，先注入代理对象，当首次使用时再创建对象完成注入。

@Component
public class CircularDependencyA {
 
    private CircularDependencyB circB;
 
    @Autowired
    public CircularDependencyA(@Lazy CircularDependencyB circB) {
        this.circB = circB;
    }
}

使用@Lazy后，运行代码，可以看到异常消除。

使用Setter/Field注入

Spring文档建议的一种方式是使用setter注入。当依赖最终被使用时才进行注入。对前文的样例代码少做修改，来观察测试效果。

@Component
public class CircularDependencyA {
 
    private CircularDependencyB circB;
 
    @Autowired
    public void setCircB(CircularDependencyB circB) {
        this.circB = circB;
    }
 
    public CircularDependencyB getCircB() {
        return circB;
    }
}

@Component
public class CircularDependencyB {
 
    private CircularDependencyA circA;
 
    private String message = "Hi!";
 
    @Autowired
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
 
    public String getMessage() {
        return message;
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { TestConfig.class })
public class CircularDependencyTest {
 
    @Autowired
    ApplicationContext context;
 
    @Bean
    public CircularDependencyA getCircularDependencyA() {
        return new CircularDependencyA();
    }
 
    @Bean
    public CircularDependencyB getCircularDependencyB() {
        return new CircularDependencyB();
    }
 
    @Test
    public void givenCircularDependency_whenSetterInjection_thenItWorks() {
        CircularDependencyA circA = context.getBean(CircularDependencyA.class);
 
        Assert.assertEquals("Hi!", circA.getCircB().getMessage());
    }
}

使用@PostConstruct

@Component
public class CircularDependencyA {
 
    @Autowired
    private CircularDependencyB circB;
 
    @PostConstruct
    public void init() {
        circB.setCircA(this);
    }
 
    public CircularDependencyB getCircB() {
        return circB;
    }
}

@Component
public class CircularDependencyB {
 
    private CircularDependencyA circA;
     
    private String message = "Hi!";
 
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
     
    public String getMessage() {
        return message;
    }
}

实现ApplicationContextAware与InitializingBean

@Component
public class CircularDependencyA implements ApplicationContextAware, InitializingBean {
 
    private CircularDependencyB circB;
 
    private ApplicationContext context;
 
    public CircularDependencyB getCircB() {
        return circB;
    }
 
    @Override
    public void afterPropertiesSet() throws Exception {
        circB = context.getBean(CircularDependencyB.class);
    }
 
    @Override
    public void setApplicationContext(final ApplicationContext ctx) throws BeansException {
        context = ctx;
    }
}

@Component
public class CircularDependencyB {
 
    private CircularDependencyA circA;
 
    private String message = "Hi!";
 
    @Autowired
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
 
    public String getMessage() {
        return message;
    }
}