java 需要了解的知识

文章目录

• 一、Java基础
• • 1.Java有哪些数据类型?
  • 2.final有什么用?
  • 3.介绍下static
  • 4."=="和equals方法究竟有什么区别？
  • 5.java中有没有引用传递？
  • 6.String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容到底变了没有？
  • 7.Error 和Exception的区别是什么？
  • 8.java程序初始化顺序是怎样的？
  • 9.java 中 IO 流分为几种？它们的区别是什么？
  • • 字符流和字节流的区别
    • • 字节流：
      • 字符流：
      • 小结：
  • 10.String为什么使用final修饰？
  • 11.BIO,NIO,AIO 有什么区别？
  • • BIO (Blocking I/O):
    • NIO (New I/O):
    • AIO (Asynchronous I/O):
  • 12.如何自定义注解？
  • 13.什么是hashCode()？
• 二、Java进阶
• • 1.什么是多态?java 中实现多态的机制是什么？
  • 2.重载和重写的区别有哪些？
  • • （1）重写总结：
    • （2）重载总结
    • 问：重载（Overload）和重写（Override）的区别？
  • 3.java重载为什么与返回值无关？
  • 4.抽象类和普通类的区别
  • 5.抽象类和接口的区别
  • 6.什么是反射?反射的实现方式?反射的应用？
  • 7.创建对象有几种方式？
  • 8.如何提高反射效率？
  • 9.类加载器有哪些？
  • 10.类加载的方式有几种，它们的区别是什么？
  • 11.JVM加载class文件的原理机制是什么(JVM的类加载的原理机制是什么)？
  • 12.什么是集合?集合和数组的区别。
  • 13.常用的集合类有哪些？它们的区别是什么？
  • 14.集合如何安全地批量删除元素?
  • 15.java怎么实现动态代理?有什么意义?
  • 16.什么是死锁?死锁产生的原因是什么?如何避免死锁？
  • 17.synchronized的作用。
  • 18.volatile关键字的作用
  • 19.线程怎么保持同步？
  • 20.什么是CAS?
  • 21.乐观锁与悲观锁?乐观锁的实现方式？
  • 22.Lock与synchronized的区别。

一、Java基础

1.Java有哪些数据类型?

2.final有什么用?

final 是最后的意思；
根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量；

final类不能被继承，没有子类，final类中的方法默认是final的；
final方法不能被子类的方法覆盖，但可以被继承；
final成员变量表示常量，只能被赋值一次，赋值后值不再改变；
final不能用于修饰构造方法；
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的；

3.介绍下static

静态变量，静态方法，静态代码块，分别阐述

（1）静态变量
什么时候需要创建静态的变量？
当创建的对象当中都存在一个相同的属性的时候，使用静态变量可以进行内存空

（2）静态方法
方法什么时候可以申明成为静态的？
方法描述的是动作，当所有的对象执行动作的时候，最终执行的结果是一样的，那么这个动作已经不属于一个对象的动作了;
可以讲此动作进行提升档次，作为模板级别的动作；

静态的方法进行调用的时候，使用类.的形式进行调用

（3）静态方法块
　　①、格式
　　在java类中（方法中不能存在静态代码块）使用static关键字和{}声明的

　　代码块：
public class CodeBlock {
    static{
        System.out.println("静态代码块");
    }
}

②、执行时机
　　静态代码块在类被加载的时候就运行了，而且只运行一次，并且优先于各种代码块以及构造函数。如果一个类中有多个静态代码块，会按照书写顺序依次执行。后面在比较的时候会通过具体实例来证明。

③、静态代码块的作用
　　一般情况下，如果有些代码需要在项目启动的时候就执行，这时候就需要静态代码块。比如一个项目启动需要加载的很多配置文件等资源，我们就可以都放入静态代码块中。
　　开机广告，运行一次

④、静态代码块不能存在任何方法体中
　　这个应该很好理解，首先我们要明确静态代码块是在类加载的时候就要运行了。我们分情况讨论：
　　
对于普通方法，由于普通方法是通过加载类，然后new出实例化对象，通过对象才能运行这个方法，而静态代码块只需要加载类之后就能运行了。

对于静态方法，在类加载的时候，静态方法也已经加载了，但是我们必须要通过类名或者对象名才能访问，也就是说相比于静态代码块，静态代码块是主动运行的，而静态方法是被动运行的。

不管是哪种方法，我们需要明确静态代码块的存在在类加载的时候就自动运行了，而放在不管是普通方法还是静态方法中，都是不能自动运行的。

⑤、静态代码块不能访问普通变量
　　这个理解思维同上，普通变量只能通过对象来调用，是不能放在静态代码块中的。

4."=="和equals方法究竟有什么区别？

“==”操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用操作符；

equals ：方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。

String a=new String("foo");

String b=new String("foo");

两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对
象，这是两个不同的对象，它们的首地址是不同的,即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个
对象中的内容是相同的，所以，表达式a.equals(b)将返回true。

小结：
== 比较的是变量的值是否相等；
equals 比较的事对象的内容是否相等；

5.java中有没有引用传递？

• 值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，在函数内对参数进行修改，不会影响到实际参数。

• 引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数内，在函数内对参数所进行的修改，将影响到实际参数。

• 通过概念我们可以得出区分值传递和引用传递的本质区别就是：实际参数的值是复制了一份，还是直接拿去用了。

Java 中只有值传递，没有引用传递，将值传递到改变函数后，只是局部变量发生了变化，本质上原来的值是没有发生变化的；

6.String s = “Hello”;s = s + " world!";这两行代码执行后，原始的 String 对象中的内容到底变了没有？

没有，因为String类是不可变类（immutable class）。不可变类，顾名思义就是说类的实例是不可被修改的。实例的信息是在创建的时候提供，并且在整个生命周期中都不可改变。在这段代码中，s原来指向一个String对象，内容是“hello”，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为”helloworld！",原来那个对象还存在内存中，只是s这个引用变量不再指向他了；
通过上面的说明，我们很容易得出一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为，String对象建立后不能改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，他允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。

7.Error 和Exception的区别是什么？

Exception 和 Error 体现了 Java 平台设计者对不同异常情况的分类，Exception 是程序正常运行过程中可以预料到的意外情况，并且应该被开发者捕获，进行相应的处理；
Error 是指正常情况下不大可能出现的情况，绝大部分的 Error 都会导致程序处于非正常、不可恢复状态。所以不需要被开发者捕获；

8.java程序初始化顺序是怎样的？

1 父类静态变量

2 父类静态代码块

3 子类静态变量

4 子类静态代码块

5 父类非静态变量

6 父类非静态代码块

7 父类构造函数

8 子类非静态变量

9 子类非静态代码块

10 子类构造函数

9.java 中 IO 流分为几种？它们的区别是什么？

• 按照流的流向分，可以分为输入流和输出流；

• 按照操作单元划分，可以划分为字节流和字符流；

• 按照流的角色划分为节点流和处理流。

Java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java I0流的40多个类都是从如下4个抽象类基类中派生出来的。

• InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。

• OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

字符流和字节流的区别

字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别：
读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

字节流：

一次读入或读出是8位二进制。通过字节的形式一个字节一个字节或者字节数组来操作文件中内容，可以操作一切文件。

字符流：

一次读入或读出是16位二进制。通过单个字符或者是字符数组的形式来操作文件的，存在一定的局限性，是专门用于对文本文件操作的，默认的版本为GBK

小结：

设备上的数据无论是图片或者视频，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据

10.String为什么使用final修饰？

11.BIO,NIO,AIO 有什么区别？

BIO (Blocking I/O):

同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。

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):

AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。

12.如何自定义注解？

注解其实就是一种标记，可以在程序代码中的关键节点（类、方法、变量、参数、包）上打上这些标记，然后程序在编译时或运行时可以检测到这些标记从而执行一些特殊操作。因此可以得出自定义注解使用的基本流程：

第一步，定义注解——相当于定义标记；
第二步，配置注解——把标记打在需要用到的程序代码中；
第三步，解析注解——在编译期或运行时检测到标记，并进行特殊操作。

13.什么是hashCode()？

hashCode和equlas的关系
1、 若两个对象相同（即用equals比较返回true），则它们的hashCode值一定要相同；
反之不成立：若两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)学习HashMap，不同的对象计算哈希码的时候，可能引起冲突;另外，Java中的集合（Collection）有两类，一类是List，再有一类是Set。;
两者区别：前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。
那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？ 这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。

2、 定义
因此，hashcode 就应遇而生了，Java就采用了hash表，利用哈希算法（也叫散列算法），就是将对象数据根据该对象的特征使用特定的算法将其定义到一个地址上，那么在后面定义进来的数据 只要看对应的hashcode地址上是否有值，那么就用equals比较，如果没有则直接插入，只要就大大减少了equals的使用次数，执行效率就大大提高了。 继续上面的话题，为什么必须要重写hashcode方法，其实简单的说就是为了保证同一个对象，保证在equals相同的情况下hashcode值必定相同，如果重写了equals而未重写 hashcode方法，可能就会出现两个没有关系的对象equals相同的（因为equal都是根据对象的特征进行重写的），但hashcode确实不相同的。

哈希（Hash）实际上是一个人名，他提出哈希算法的概念，于是以名字名之。 哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。

二、Java进阶

1.什么是多态?java 中实现多态的机制是什么？

（1）现实中，比如我们按下 F1 键这个动作：
如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。

（2）多态的实现方式
方式一：重写 与 重载

方式二：接口

• 1 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
• 2 java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。

方式三：抽象类和抽象方法
详情请看 Java抽象类 章节。

2.重载和重写的区别有哪些？

（1）重写总结：

从字面上看，重写就是 重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。
1.发生在父类与子类之间
2.方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同
3.访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)
4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常

（2）重载总结

在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。
1.重载Overload是一个类中多态性的一种表现
2.重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)
3.重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

问：重载（Overload）和重写（Override）的区别？

• 方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性；
• 重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；
• 重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）；
• 重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

3.java重载为什么与返回值无关？

因为java里允许调用一个有返回值的方法的时候不必将返回值赋给变量，这样JVM就不知道你调用的是有返回值的还是没返回值的;
这样一来 java 的重载重语言的设计之初，就规定重载与返回值无关；

举个例子：

class Test{
  public static void testMethod(){
  }
  public static int testMethod(){
  }//姑且假设允许吧
  public static void main(String[] args){
    int i = testMethod();//这个还说的过去 知道是调用哪个
    testMethod();//这个就无法判断调用哪个方法了
  } 
}

4.抽象类和普通类的区别

（1）简单理解什么是抽象
抽象性和具体性都是相对的，不是绝对的。简单说，概念的内涵越小，则其抽象程度就越高，其外延也越大，反之亦然。比如“人”比“男人”抽象一点，而“生物”又比“人”更抽象一点，“物质”则比“生物”更抽象。
抽象的概念是由具体概念依其“共性”而产生的，把具体概念的诸多个性排出，集中描述其共性，就会产生一个抽象性的概念。抽象思维，是人类思维达到高级阶段产生的一种能力，例如，当小孩子思维尚未成熟时，他们只能掌握具体概念，他们在学习代词“你、我、他”时往往遇到困难，因为代词具有较高的抽象性。
总之，抽象概念的外延大，内涵小，具体概念的外延小，内涵大。
（2）抽象类与普通类的区别：
1、普通类可以去实例化调用；抽象类不能被实例化，因为它是存在于一种概念而不非具体。
2、普通类和抽象类都可以被继承，但是抽象类被继承后子类必须重写继承的方法，除非子类也是抽象类。

5.抽象类和接口的区别

1、概念不一样
接口是对动作的抽象，抽象类是对本质的抽象。
抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它。
所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

2、使用不一样：
a.抽象类 和 接口 都是用来抽象具体对象的. 但是接口的抽象级别最高
b.抽象类可以有具体的方法 和属性, 接口只能有抽象方法和不可变常量
c.抽象类主要用来抽象类别,接口主要用来抽象功能.
d.抽象类中，且不包含任何实现，派生类必须覆盖它们。接口中所有方法都必须是未实现的。
e.接口是设计的结果 ，抽象类是重构的结果

3、使用方向：当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
注意：抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。

6.什么是反射?反射的实现方式?反射的应用？

（1）什么是反射？
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

（2）反射的实现方式？
获取任意类的字节码对象的几种方式

Class c1=GetSum.class；//注意Class要大写C
获取类对象

Class c2 = Test.getClass();
// 获取类对象

Class.forName("类的相对路径");//实现类的加载

三种方式获取的字节码对象是同一个；

（3）反射的应用场景
反射是框架设计的灵魂
在我们平时的项目开发过程中，基本上很少会直接使用到反射机制，但这不能说明反射机制没有用，实际上有很多设计、开发都与反射机制有关，例如模块化的开发，通过反射去调用对应的字节码；动态代理设计模式也采用了反射机制，还有我们日常使用的 Spring／Hibernate 等框架也大量使用到了反射机制。
举例：

• 我们在使用 JDBC 连接数据库时使用 Class.forName()通过反射，加载数据库的驱动程序；
• Spring 框架的 IOC（动态加载管理 Bean）创建对象以及 AOP（动态代理）功能都和反射有联系；
• 动态配置实例的属性；

几点理解：

• Class类也是类的一种，只是名字和class关键字高度相似
• Class类的对象是创建的类的相关信息，比如创建一个cat类，那么java就会生成一个内容是cat类的Class类对象
• 在cat类加载时会为每个类生成一个Class类的对象在堆中，每个cat类型的实例都要通过这个Class对象来进行实例化
• 无论一个类有多少实例对象，在JVM中都只有一个Class对象
• Class类的对象内容是你创建的类的类型信息，比如你创建一个shapes类，那么，Java会生成一个内容是shapes的Class类的对象
• Class类的对象不能像普通类一样，以 new shapes() 的方式创建，它的对象只能由JVM创建，因为这个类没有public构造函数
• Class类的作用是运行时提供或获得某个对象的类型信息，和C++中的typeid()函数类似。这些信息也可用于反射。

7.创建对象有几种方式？

有4种显式地创建对象的方式：
1.用new语句创建对象，这是最常用的创建对象的方式；
2.运用反射手段，调用Java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法；
3.调用对象的clone()方法；
4.运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法；

8.如何提高反射效率？

9.类加载器有哪些？

10.类加载的方式有几种，它们的区别是什么？

11.JVM加载class文件的原理机制是什么(JVM的类加载的原理机制是什么)？

12.什么是集合?集合和数组的区别。

13.常用的集合类有哪些？它们的区别是什么？

14.集合如何安全地批量删除元素?

15.java怎么实现动态代理?有什么意义?

16.什么是死锁?死锁产生的原因是什么?如何避免死锁？

17.synchronized的作用。

18.volatile关键字的作用

19.线程怎么保持同步？

20.什么是CAS?

21.乐观锁与悲观锁?乐观锁的实现方式？

22.Lock与synchronized的区别。

三、MyBatis
1.MyBatis是什么？

2.ORM是什么？

3.为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？

4.传统JDBC开发存在的问题。

5.JDBC编程有哪些不足之处，MyBatis是如何解决这些问题的？

6.Mybatis优缺点。

7.MyBatis框架适用场景。

8.Hibernate和MyBatis的区别。

9.MyBatis的解析和运行原理。

10.MyBatis编程步骤是什么样的？

11.请说说MyBatis的工作原理。

12.MyBatis的功能架构是怎样的？

13.MyBatis的框架架构设计是怎么样的？

14.Mybatis都有哪些Executor执行器？它们之间的区别是什么？

15.Mybatis中如何指定使用哪一种Executor执行器？

16.Mybatis是否支持延迟加载？如果支持，它的实现原理是什么？

17.#{}和${}的区别。

18.模糊查询like语句该怎么写？

19.在mapper中如何传递多个参数？

20.Mybatis如何执行批量操作？

21.简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系？

四、Spring
1.什么是spring?Spring是什么?

2.Spring的优缺点是什么？为什么要用Spring?

3.什么是控制反转(IOC)和依赖注入(DI)?意义是什么?实现机制是什么

4.什么是依赖注入–DI，依赖注入，是IOC的重要实现

5.什么是AOP?意义是什么?实现原理是什么?具体怎么使用?Spring AOP的通知类型和顺序是怎样的?

6.什么是AOP–面向切面编程？

7.静态代理和动态代理的区别是什么？

8.如何强制Spring AOP使用CGLIB实现动态代理？

9.依赖注入实现原理和实现方式？

10.@Qualifier 注解有什么作用？

11.Spring中对象的作用域是怎样的?怎么改变Spring中对象的作用域?

12.Spring中对象是线程安全的吗?如何保证Spring中的对象线程安全?

13.如何保证Spring中的对象线程安全？

14.Spring Framework 中有多少个模块，它们分别是什么？

五、并发编程
基础知识

1.线程和进程区别

2.创建线程的四种方式

3.as-if-serial规则和happens-before规则的区别

…

Lock体系

1.Lock简介与初识AQS

2.乐观锁的实现方式，什么是 CAS？

3.什么是死锁？

4.死锁与活锁的区别，死锁与饥饿的区别？

5.AQS( AbstractQueuedSynchronizer)详解与源码分析

并发容器

1.并发容器之CopyOnWriteArrayList详解

2.并发容器之ThreadLocal详解

3.并发容器之ConcurrentHashMap详解(JDK1.8版本)与源码分析

4.并发容器之BlockingQueue详解

5.ThreadLocal内存泄漏分析与解决方案

线程池

1.Executors类创建四种常见线程池

2.线程池之ThreadPoolExecutor详解

六、中间件
RabbitMQ

1.rabbitmq 的使用场景有哪些？

2.rabbitmq 有哪些重要的角色？

3.rabbitmq 有哪些重要的组件？

4.rabbitmq 中 vhost 的作用是什么？

5.rabbitmq 的消息是怎么发送的？

6.rabbitmq 怎么保证消息的稳定性？

7.rabbitmq 怎么避免消息丢失？

8.要保证消息持久化成功的条件有哪些？

9.rabbitmq 持久化有什么缺点？

10.rabbitmq 怎么实现延迟消息队列？

11.rabbitmq 对集群节点停止顺序有要求吗？

Kafka

1.kafka 可以脱离 zookeeper 单独使用吗？为什么？

2.kafka 有几种数据保留的策略？

3.kafka 同时设置了 7 天和 10G 清除数据，到第五天的时候消息达到了 10G，这个时候 kafka 将如何处理？

4.什么情况会导致 kafka 运行变慢？

5.使用 kafka 集群需要注意什么？

Zookeeper

1.zookeeper 是什么？

2.zookeeper 都有哪些功能？

3.zookeeper 有几种部署模式？

4.zookeeper 怎么保证主从节点的状态同步？

5.集群中为什么要有主节点？

6.集群中有 3 台服务器，其中一个节点宕机，这个时候 zookeeper 还可以使用吗？

7.说一下 zookeeper 的通知机制？

七、数据库
MySql

1.说一下数据库的事务隔离？

2.说一下 mysql 常用的引擎？

3.说一下 mysql 的行锁和表锁？

4.说一下乐观锁和悲观锁？

5.mysql 问题排查都有哪些手段？

6.如何做 mysql 的性能优化？

7.怎么验证 mysql 的索引是否满足需求？

8.数据库的三范式是什么？

9.说一下 ACID 是什么？

10.如何获取当前数据库版本？

Redis

1.redis是什么？都有哪些使用场景？

2.redis 和 memecache 有什么区别？

3.redis 为什么是单线程的？

4.edis 和 redisson 有哪些区别？

5.怎么保证缓存和数据库数据的一致性？

6.redis 持久化有几种方式？

7.redis 怎么实现分布式锁？

8.redis 分布式锁有什么缺陷？

9.redis 如何做内存优化？

10.redis 淘汰策略有哪些？

JVM

1.说一下 jvm 运行时数据区？

2.说一下堆栈的区别？

3.队列和栈是什么？有什么区别？

4.什么是双亲委派模型？

5.说一下类加载的执行过程？

6.怎么判断对象是否可以被回收？

7.java 中都有哪些引用类型？

8.说一下 jvm 有哪些垃圾回收算法？

9.说一下 jvm 有哪些垃圾回收器？

10.详细介绍一下 CMS 垃圾回收器？

总结
面试题包括以下十九个模块： Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。