Java技术面试基本面试题（高频）

一 、String 的特征有哪些？

●不变性：String是只读字符串，是一个典型的immutable对象，对它进行任何操作，其实都是创建一个新的对象，，再把引用指向该对象。不变模式的主要作用在于当一个对象需要被多线程共享并频繁访问时，可以保证数据的一致性。
●常量池优化：String对象创建之后，会在字符串常量池中进行缓存，如果下次创建同样的对象时，会直接返回缓存的引用。
●final：使用final来定义String类，表示String类不能被继承，提高了系统的安全性。

二、String为什么要有常量池？

String是存储在Java堆内存中的字符串池.JVM 为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化。为 了减少在JVM中创建的字符串的数量，字符串类维护了一个字符串池，每当代码创建字符串常量时，JVM会首先检查字符串常量池。如果字符串已经存在池中， 就返回池中的实例引用。如果字符串不在池中，就会实例化一个字符串并放到池中。

三、StringBuilder和StringBuffer有什么区别？

StringBuffer是可变类，和线程安全的字符串操作类，效率低,速度慢。
StingBuilder线程不安全,但速度快效率高。

四、JAVA集合框架有哪些常用的数据结构?

1.Java集合框架主要包括Collection和Map两种类型。其中Collection又有3种子类型，分别是List、Set、Queue。Map中存储的主要是键值对映射。
2.规则集Set中存储的是不重复的元素，线性表中存储可以包括重复的元素，Queue队列描述的是先进先出的数据结构，可以用LinkedList来实现队列。
3.效率上，规则集比线性表更高效。
4.ArrayList主要是用数组来存储元素，LinkedList主要是用链表来存储元素，HashMap的底层实现主要是借助数组+链表+红黑树来实现。
5.Vector、HashTable等集合类效率比较低但都是线程安全的。包java.util.concurrent下包含了大量线程安全的集合类，效率上有较大提升。

五、HashMap的底层实现？

1.HashMap的数据结构

哈希表结构（链表散列：数组+链表）实现，结合数组和链表的优点。当链表长度超过8时，链表转化为红黑树。
transient Node<K,V>[] table;

2.HashMap的工作原理

HashMap底层是hash数组和单向链表实现，数组中的每个元素都是链表，由Node内部类（实现Map.Entry<K,V>接口）实现，HashMap通过put&get方法存储和获取。
存储对象时，将K/V键值传给put()方法：
①调用hash(K)方法计算K的hash值，然后结合数组长度，计算得到数组下标；

②调整数组大小（当容器中的元素个数大于capacity*loadfactory时，容器会进行扩容resize为2n）；

③i.如果K的hash值在HashMap中不存在，则执行插入，若存在，则发生碰撞；
ii.如果K的hash值在HashMap中存在，且它们两者equals返回true,则更新键值对；
iii.如果K的hash值在HashMap中存在，且它们两者equals返回false，则插入链表的尾部（尾插法）或者红黑树中（树的添加方式）。

（JDK1.7之前使用头插法，JDK14.8使用尾插法）
（注意：当碰撞导致链表TREEIFY_THRESHOLD=8时，就把链表转换为红黑树）

获取对象时，将K传给get()方法：
①调用hash(K)方法（计算K的hash值）从而获取该键值所在链表的数组下标；
②顺序遍历链表，equals()方法查找相同Node链表中K值对应的V值

hashCode是定位的，存储位置；equals是定性的，比较两者是否相等。

3.当两个对象的hashCode相同会发生什么？

因为hashCode相同，不一定就是相等的（equals方法比较），所以两个对象所在数组的下标相同，“碰撞”就此发生。又因为HashMap使用链表存储对象，这个Node会存储到链表中。

4.你知道hash的实现吗？为什么要这样实现？

JDK1.8中，是通过hashCode()的高16位异或低16位实现的：（h=k.hashCode()）^(h >>> 16),主要是从速度，功效和质量来考虑的，减少系统的开销，也不会造成因为高位没有参与下标的计算，从而引起的碰撞。

5.为什么要用异或运算符

保证了对象的hashCode的32位值只要有一位发生改变，整个hash()返回值就会改变。尽可能的减少碰撞。

6.HashMap 的 table 的容量如何确定？loadFactor 是什么？该容量如何变化？这种变化会带来什么问题？

①、table 数组大小是由 capacity 这个参数确定的，默认是16，也可以构造时传入，最大限制是1<<30；
②、loadFactor 是装载因子，主要目的是用来确认table 数组是否需要动态扩展，默认值是0.75，比如table 数组大小为 16，装载因子为 0.75 时，threshold 就是12，当 table 的实际大小超过 12 时，table就需要动态扩容；
③、扩容时，调用 resize() 方法，将 table 长度变为原来的两倍（注意是 table 长度，而不是 threshold）
④、如果数据很大的情况下，扩展时将会带来性能的损失，在性能要求很高的地方，这种损失很可能很致命。

7.HashMap中put方法的过程？

答：调用哈希函数获取Key对应的hash值，再计算其数组下标；

如果没有出现哈希冲突，则直接放入数组；

如果出现哈希冲突，则以链表的方式放在链表后面；

●如果链表长度超过阀值( TREEIFY THRESHOLD==8)，就把链表转成红黑树，链表长度低于6，就把红黑树转回链表;
●如果结点的key已经存在，则替换其value即可；
●如果集合中的键值对大于12，调用resize方法进行数组扩容。

8.数组扩容的过程？

创建一个新的数组，其容量为旧数组的两倍，并重新计算旧数组中结点的存储位置。结点在新数组中的位置只有两种，原下标位置或原下标+旧数组的大小。

9.拉链法导致的链表过深问题为什么不用二叉查找树代替，而选择红黑树？为什么不一直使用红黑树？

之所以选择红黑树是为了解决二叉查找树的缺陷，二叉查找树在特殊情况下会变成一条线性结构（这就跟原来使用链表结构一样了，造成很深的问题），遍历查找会非常慢。而红黑树在插入新数据后可能需要通过左旋，右旋、变色这些操作来保持平衡，引入红黑树就是为了查找数据快，解决链表查询深度的问题，我们知道红黑树属于平衡二叉树，但是为了保持“平衡”是需要付出代价的，但是该代价所损耗的资源要比遍历线性链表要少，所以当长度大于8的时候，会使用红黑树，如果链表长度很短的话，根本不需要引入红黑树，引入反而会慢。

10.说说你对红黑树的见解？

1、每个节点非红即黑

2、根节点总是黑色的

3、如果节点是红色的，则它的子节点必须是黑色的（反之不一定）

4、每个叶子节点都是黑色的空节点（NIL节点）

5、从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）

11.jdk8中对HashMap做了哪些改变？

在java 1.8中，如果链表的长度超过了8，那么链表将转换为红黑树。
（桶的数量必须大于64，小于64的时候只会扩容）
发生hash碰撞时，java 1.7 会在链表的头部插入，而java 1.8会在链表的尾部插入
在java 1.8中，Entry被Node替代(换了一个马甲)。

12.HashMap，LinkedHashMap，TreeMap 有什么区别？

HashMap 参考其他问题；
LinkedHashMap 保存了记录的插入顺序，在用 Iterator 遍历时，先取到的记录肯定是先插入的；遍历比 HashMap 慢；

TreeMap 实现 SortMap 接口，能够把它保存的记录根据键排序（默认按键值升序排序，也可以指定排序的比较器）

13.HashMap & TreeMap & LinkedHashMap 使用场景？

一般情况下，使用最多的是 HashMap。
HashMap：在 Map 中插入、删除和定位元素时；
TreeMap：在需要按自然顺序或自定义顺序遍历键的情况下；
LinkedHashMap：在需要输出的顺序和输入的顺序相同的情况下。

14.HashMap 和 HashTable 有什么区别？

① HashMap 是线程不安全的，HashTable 是线程安全的；
② 由于线程安全，所以 HashTable 的效率比不上 HashMap；
③ HashMap最多只允许一条记录的键为null，允许多条记录的值为null，而 HashTable不允许；
④ HashMap 默认初始化数组的大小为16，HashTable 为 11，前者扩容时，扩大两倍，后者扩大两倍+1；
⑤ HashMap 需要重新计算 hash 值，而 HashTable 直接使用对象的 hashCode

15.Java 中的另一个线程安全的与 HashMap 极其类似的类是什么？同样是线程安全，它与 HashTable 在线程同步上有什么不同？

ConcurrentHashMap 类（是 Java并发包 java.util.concurrent 中提供的一个线程安全且高效的 HashMap 实现）。

HashTable 是使用 synchronize 关键字加锁的原理（就是对对象加锁）；

而针对 ConcurrentHashMap，在 JDK 1.7 中采用 分段锁的方式；JDK 1.8 中直接采用了CAS（无锁算法）+ synchronized。

16.HashMap & ConcurrentHashMap 的区别？

除了加锁，原理上无太大区别。另外，HashMap 的键值对允许有null，但是ConCurrentHashMap 都不允许。

17.为什么 ConcurrentHashMap 比 HashTable 效率要高？

HashTable 使用一把锁（锁住整个链表结构）处理并发问题，多个线程竞争一把锁，容易阻塞；

ConcurrentHashMap

JDK 1.7 中使用分段锁（ReentrantLock + Segment + HashEntry），相当于把一个 HashMap 分成多个段，每段分配一把锁，这样支持多线程访问。

锁粒度：

基于 Segment，包含多个 HashEntry。

JDK 1.8 中使用 CAS + synchronized + Node + 红黑树。

锁粒度：

Node（首结点）（实现 Map.Entry<K,V>）。锁粒度降低了。

18.针对 ConcurrentHashMap 锁机制具体分析（JDK 1.7 VS JDK 1.8）？

JDK 1.7 中，采用分段锁的机制，实现并发的更新操作，底层采用数组+链表的存储结构，包括两个核心静态内部类 Segment 和 HashEntry。

① Segment 继承 ReentrantLock（重入锁） 用来充当锁的角色，每个 Segment 对象守护每个散列映射表的若干个桶；
② HashEntry 用来封装映射表的键-值对；
③ 每个桶是由若干个 HashEntry 对象链接起来的链表

JDK 1.8 中，采用Node + CAS + Synchronized来保证并发安全。取消类 Segment，直接用 table 数组存储键值对；当 HashEntry 对象组成的链表长度超过 TREEIFY_THRESHOLD 时，链表转换为红黑树，提升性能。底层变更为数组 + 链表 + 红黑树。

19.ConcurrentHashMap 在 JDK 1.8 中，为什么要使用内置锁 synchronized 来代替重入锁 ReentrantLock？

① 粒度降低了；

② JVM 开发团队没有放弃 synchronized，而且基于 JVM 的 synchronized 优化空间更大，更加自然。

③ 在大量的数据操作下，对于 JVM 的内存压力，基于 API 的 ReentrantLock 会开销更多的内存。

20.ConcurrentHashMap 简单介绍？

① 重要的常量：private transient volatile int sizeCtl;
当为负数时，-1 表示正在初始化，-N 表示 N - 1 个线程正在进行扩容；
当为 0 时，表示 table 还没有初始化；
当为其他正数时，表示初始化或者下一次进行扩容的大小。

② 数据结构：

Node 是存储结构的基本单元，继承 HashMap 中的 Entry，用于存储数据；
TreeNode 继承 Node，但是数据结构换成了二叉树结构，是红黑树的存储结构，用于红黑树中存储数据；
TreeBin 是封装 TreeNode 的容器，提供转换红黑树的一些条件和锁的控制。

③、存储对象时（put() 方法）：

1.如果没有初始化，就调用 initTable() 方法来进行初始化；

2.如果没有 hash 冲突就直接 CAS 无锁插入；

3.如果需要扩容，就先进行扩容；

4.如果存在 hash 冲突，就加锁来保证线程安全，两种情况：一种是链表形式就直接遍历到尾端插入，一种是红黑树就按照红黑树结构插入；

5.如果该链表的数量大于阀值 8，就要先转换成红黑树的结构，break 再一次进入循

6.如果添加成功就调用 addCount() 方法统计 size，并且检查是否需要扩容。

④ 扩容方法 transfer()：默认容量为 16，扩容时，容量变为原来的两倍。
helpTransfer()：调用多个工作线程一起帮助进行扩容，这样的效率就会更高。

⑤、获取对象时（get()方法）：

1.计算 hash 值，定位到该 table 索引位置，如果是首结点符合就返回；
2.如果遇到扩容时，会调用标记正在扩容结点 ForwardingNode.find()方法，查找该结点，匹配就返回；
3.以上都不符合的话，就往下遍历结点，匹配就返回，否则最后就返回 null。

21.ConcurrentHashMap 的并发度是什么？

程序运行时能够同时更新 ConccurentHashMap 且不产生锁竞争的最大线程数。默认为 16，且可以在构造函数中设置。当用户设置并发度时，ConcurrentHashMap 会使用大于等于该值的最小2幂指数作为实际并发度（假如用户设置并发度为17，实际并发度则为32）

六、线程的创建方式有哪些？

答：有三种方式可以创建线程：
●继承Thread类
●实现Runnable接口
●应用程序可以使用Executor框架来创建线程池
实现Runnable接口这种方式更受欢迎，因为这不需要继承Thread类。在应用设计中已经继承了别的对象的情况下，这需要多继承（Java中不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用。

七、造成线程阻塞的方法有哪些？

线程睡眠：Thread.sleep sleep()释放CPU执行权，但不释放同步锁；

线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 唤醒方法，wait()释放CPU执行权，也释放同步锁

线程礼让，Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。

执行join方法，暂停当前执行的线程，去执行另一个含join的线程，直到运行结束后，才进入就绪状态。

八、线程的生命周期？

线程的生命周期包含5个阶段，包括：新建、就绪、运行、阻塞、销毁。
●新建：就是刚使用new方法，new出来的线程；
●就绪：就是调用的线程的start()方法后，这时候线程处于等待CPU分配资源阶段，谁先抢的CPU资源，谁开始执行;
●运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能;
●阻塞：在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态
●销毁：如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束，那么线程就要被销毁，释放资源

九、Servlet的生命周期？

●Servlet 初始化后调用 init () 方法。
●Servlet 调用 service() 方法来处理客户端的请求。
●Servlet 销毁前调用 destroy() 方法。

十、转发和重定向有什么区别？

1、请求次数：重定向是浏览器向服务器发送一个请求并收到响应后再次向一个新地址发出请求，转发是在服务器端内部将请求转发到另外一个资源；重定向至少请求两次，转发请求一次；
2、地址栏不同：重定向地址栏会发生变化，转发地址栏不会发生变化；
3、是否共享数据：重定向两次请求不共享数据，转发一次请求共享相同的request对象和response对象
4、跳转限制：重定向可以跳转到任意URL，转发只能跳转本站点资源；
5、发生行为不同：重定向是客户端行为，转发是服务器端行为；

十一、数据库的约束有哪些？

主键约束（Primary Key constraint）：要求主键列数据唯一，并且不允许为空。
唯一约束（Unique constraint）：要求该列唯一，允许为空，但只能出现一个空值。
检查约束（Check constraint）：某列取值范围限制，格式限制等，如有关年龄、邮箱（必须有@）的约束。
默认约束（Default constraint）：某列的默认值，如在数据库里有一项数据很多重复，可以设为默认值。
外键约束（Foreign Key constraint）：用于在两个表之间建立关系，需要指定引用主表的哪一列。

十二、数据库设计的三范式？

第一范式条件：必须不包含重复组的关系，即每一列都是不可拆分的原子项。
第二范式条件：关系模式必须满足第一范式，并且所有非主属性都完全依赖于主码。当某张表中的非主键信息不是由整个主键函数来决定时，即存在依赖于该表中不是主键的部分或者依赖于主键一部分的部分时，通常会违反2NF。
第三范式的条件：关系模型满足第二范式，所有非主属性对任何候选关键字都不存在传递依赖。即每个属性都跟主键有直接关系而不是间接关系

十三、数据库的索引有哪些？

唯一索引：在创建唯一索引时要不能给具有相同的索引值。
主键索引：在我们给一个字段设置主键的时候，它就会自动创建主键索引，用来确保每一个值都是唯一的。
聚集索引：我们在表中添加数据的顺序，与我们创建的索引键值相同，而且一个表中只能有一个聚集索引。
普通索引：它的结构主要以B+树和哈希索引为主，主要是对数据表中的数据进行精确查找。
全文索引：它的作用是搜索数据表中的字段是不是包含我们搜索的关键字，就像搜索引擎中的模糊查询。

十四、事务的四大特征?

原子性，事务的原子性表示事务执行过程中，把事务作为一个工作单元处理，一个工作单元可能包括若干个操作步骤，每个操作步骤都必须完成才算完成，若因任何原因导致其中的一个步骤操作失败，则所有步骤操作失败，前面的步骤必须回滚。

一致性，事务的一致性保证数据处于一致状态。如果事务开始时系统处于一致状态，则事务结束时系统也应处于一致状态，不管事务成功还是失败。

隔离性，事务的隔离性保证事务访问的任何数据不会受到其他事务所做的任何改变的影响，直到该事务完成。

持久性，事务的持久性保证加入事务执行成功，则它在系统中产生的结果应该是持久的。

十五、事务隔离级别有哪些？

Read uncommitted
读未提交，顾名思义，就是一个事务可以读取另一个未提交事务的数据。
Read committed
读提交，顾名思义，就是一个事务要等另一个事务提交后才能读取数据。
Repeatable read
重复读，就是在开始读取数据（事务开启）时，不再允许修改操作
Serializable 序列化
Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读

十六、什么是IOC和DI?

IOC叫控制反转，是Inversion of Control的缩写。，将对在自身对象中的一个内置对象的控制反转，反转后不再由自己本身的对象进行控制这个内置对象的创建，而是由第三方系统去控制这个内置对象的创建。
DI（Dependency Injection）叫依赖注入，意思自身对象中的内置对象是通过注入的方式进行创建。。控制反转是把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。

十七、什么是过滤器什么拦截器？

过滤器（filter）
filter是javaweb的servlet体系内，依赖servlet容器，一般用于对请求request和响应response的信息进行过滤，比如：过滤参数、字符编码、敏感字符等
拦截器（Interceptor）
interceptor是SpringMVC体系内，依赖Spring容器，基于AOP动态代理实现的，一般常用于对业务层的业务方法进行处理，比如实现系统日志、事务机制、权限检查、性能监控等，通过拦截器就比较好实现。虽然过滤器也是可以实现日志记录、权限检查等效果，但是过滤器只能在servlet前后执行，而拦截器则可以深入到方法执行前后、异常抛出前后执行，所以在Spring体系内，推荐使用拦截器进行日志和事务的实现。

Spring内部就有一个拦截器，比如事物拦截器、日志的拦截器，实现的原理就是就是使用AOP的切面，进行配置切点，在配置拦截器中有配置前置通知、后置通知、异常通知和环绕通知。
只需要写一个拦截器的类，内部配置方法
Spring的拦截器其实和servlet内的过滤器filter的作用其实差不多，两者其实没有什么可比性，两者不属于同一个技术体系内部的，若真的有区别，就是一个执行时机的区别，只是在项目中，请求先经过servlet的过滤器，才会进入到Spring，进入Spring项目内部，才会执行拦截器的功能。

十八、Aop怎么实现的？

AOP实现共有两种方式，即AspectJ静态代理 和 AOP动态代理

十九、SpringBean的作用域有哪些？五个

Spring 3 中 为 Bean定义了5种作用域，分别是 singleton（单例），prototype(原型)，request，session和global session。
1.singleton：单例模式（多线程下不安全）
单例模式。Spring IOC 容器中只会存在一个共享的Bean实例，无论有多少个Bean引用它，都指向同一个对象。该模式在多线程下是不安全的。Singleton作用域是spring中的缺省作用域，也可以显示的将Bean定义为单例模式
2.prototype ：原型模式每次使用时创建
原型模式，每次通过Spring容器获取prototype定义的bean时，容器都能创建一个新的Bean实例，每个Bean实例都有自己的属性和状态，而singleton对象全局只有一个对象。根据经验，对有状态的bean使用prototype作用域，而对无状态的bean使用singleton作用域。
3.Request：一次request一个实例
request：在一次http请求中，容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean，而且该bean仅在当前的Http Request内有效，当前Http请求结束，该bean的实例也将会被销毁。
4.session
session：在一次Http Session 中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，改bean实例仅在当前Session内有效。同Http 请求相同，每一次session请求创建新的实例，而不同的实例之间不共享属性，且实例仅在自己的session请求内有效，请求结束，则实例将被销毁。
5.global Session
在一个全局的Http Session中，容器会返回该Bean的同一个实例，仅在使用portlet context 时有效

二十、动态代理有哪些？

Spring AOP是动态代理，AOP框架不会去修改字节码，而是在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的所有方法，并且在特定的切点做了增强处理，并回调原对象的方法
1.JDK动态代理
1.1通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口
2、JDK动态代理的核心是实现 InvocationHandler（invoke方法）接口和 Proxy 类
2、CGLIB动态代理
2.1、如果目标类没有实现接口，AOP会选择使用CGLIB来动态代理目标类
2.2、CGLIB（Code Generation Library）是一个代码生成的类库，可以在运行时动态的生成某个类的子类（继承关系）
3、通过继承的方式做动态代理，如果目标类被final修饰，它是无法使用CGLIB做动态代理的

二十一、SpringMvc的请求处理流程？

1.客户端发送请求到后台服务器；

2.springmvc核心控制器DispatcherServlet统一接收请求，并根据请求的url找到HandlerMapping映射的Controller;

3.Controller里面调用业务方法完成业务处理,包括与持久层交互，完成数据持久化;

4.Controller处理完业务方法后返回对应的ModelAndView(模型视图)对象，包含了返回的页面以及数据模型;

5.DispatcherServlet接收返回的ModelAndView对象，通过ViewResolver视图解析器找到对应的界面并进行页面渲染，最后页面在前端呈现出来。

二十二、Redis支持哪些数据结构？

Redis是一个支持key-value形式的内存数据库。其中，key为字符串，value支持5种类型的数据结构。
value支持的5种类型的数据结构如下。
1，string。这是Redis最基本的结构。
2，list。redis的value可以是若干个字符串组成的列表。
3，set。集合。value可以是若干个字符串组成的集合。
4，zset，有序集合。zset是在set的基础上增加了排序的功能。
5，hash。redis的value本身，可以是一个hash表，由若干个key-value对组成。

二十三、Redis去实现分布式事务锁？

使用redis命令 set key value NX EX（PX） max-lock-time 实现加锁
使用redis命令 EVAL 实现解锁
加锁操作：jedis.set(key,value,“NX”,“EX”,timeOut)【保证加锁的原子操作】
key就是redis的key值作为锁的标识，value在这里作为客户端的标识，只有key-value都比配才有删除锁的权利【保证安全性】
通过timeOut设置过期时间保证不会出现死锁【避免死锁】
NX（XX），EX（PX）什么意思？
NX：只有这个key不存才的时候才会进行操作，if not exists；
XX：只有这个key存才的时候才会进行操作，if exists；
EX：设置key的过期时间为秒，具体时间由第5个参数决定
PX：毫秒为单位

Loading…