史上最全java全方位总结以及答案

JAVA基础

JAVA中的几种基本数据类型是什么，各自占用多少字节。
1. java的基本数据类型有八种：
  
  1）四种整数类型(byte、short、int、long)：    byte：8 位，用于表示最小数据单位，如文件中数据，-128~127    short：16 位，很少用，-32768 ~ 32767    int：32 位、最常用，-2^31-1~2^31 （21 亿）    long：64 位、次常用    注意事项：    int i=5; // 5 叫直接量（或字面量），即直接写出的常数。    整数字面量默认都为 int 类型，所以在定义的 long 型数据后面加 L或 l。    小于 32 位数的变量，都按 int 结果计算。    强转符比数学运算符优先级高。见常量与变量中的例子。
  
  2）两种浮点数类型(float、double)：    float：32 位，后缀 F 或 f，1 位符号位，8 位指数，23 位有效尾数。    double：64 位，最常用，后缀 D 或 d，1 位符号位，11 位指数，52 位有效尾    注意事项：    二进制浮点数： 1010100010=101010001.0*2=10101000.10*2^10（2次方)=1010100.010*2^11(3次方)= . 1010100010*2^1010(10次方)    尾数： . 1010100010   指数：1010   基数：2    浮点数字面量默认都为 double 类型，所以在定义的 float 型数据后面加F 或 f；double 类型可不写后缀，但在小数计算中一定要写 D 或 X.X    float 的精度没有 long 高，有效位数（尾数）短。    float 的范围大于 long 指数可以很大。    浮点数是不精确的，不能对浮点数进行精确比较。
  
  3）一种字符类型(char)：    char：16 位，是整数类型，用单引号括起来的 1 个字符（可以是一个中文字符），使用 Unicode 码代表字符，0~2^16-1（65535）。    注意事项：    不能为 0个字符。    转义字符：\n 换行 \r 回车 \t Tab 字符 \" 双引号 \\ 表示一个\    两字符 char 中间用“+”连接，内部先把字符转成 int 类型，再进行加法运算，char 本质就是个数！二进制的，显示的时候，经过“处理”显示为字符。
  
  4）一种布尔类型(boolean)：true 真和 false 假。
  
  5）类型转换：       char-->    自动转换：byte-->short-->int-->long-->float-->double                   强制转换：①会损失精度，产生误差，小数点以后的数字全部舍弃。②容易超过取值范围。
  
  6）记忆：8位：Byte（字节型）          16位：short（短整型）、char（字符型）          32位：int（整型）、float（单精度型/浮点型）          64位：long（长整型）、double（双精度型）          最后一个：boolean(布尔类型
String类能被继承吗，为什么。
1. 不能被继承，因为String类有final修饰符，而final修饰的类是不能被继承的。
  
  Java对String类的定义：
  
  public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
  
  // 省略...
  
  }
  
  final修饰符的用法：
  
  1.修饰类
  
  　　当用final修饰一个类时，表明这个类不能被继承。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
  
  2.修饰方法
  
  　　使用final修饰方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。
  
  　　因此，只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final。
  
  　　注：一个类中的private方法会隐式地被指定为final方法。
  
  3.修饰变量
  
  　　对于被final修饰的变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。虽然不能再指向其他对象，但是它指向的对象的内容是可变的。
  
  final和static的区别：
  
  很多时候会容易把static和final关键字混淆，static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。看下面这个例子：
  
  1 public class Demo1 { 2 public static void main(String[] args) { 3 MyClass myClass1 = new MyClass(); 4 MyClass myClass2 = new MyClass(); 5 System.out.println(myClass1.i); 6 System.out.println(myClass2.i); 7 System.out.println(myClass1.j); 8 System.out.println(myClass2.j); 9 10 }11 }12 13 class MyClass {14 public final double i = Math.random();15 public static double j = Math.random();16 }
  
  运行结果：
  
  0.3222977275463088
  
  0.2565532218939688
  
  0.36856868882926397
  
  0.36856868882926397
  
  每次打印的两个j值都是一样的，而i的值却是不同的。从这里就可以知道final和static变量的区别了。
String，Stringbuffer，StringBuilder的区别。
1. 这三个类之间的区别主要是在两个方面，即运行速度和线程安全这两方面。
  
  首先说运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String
  
  String最慢的原因：
  
  String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。以下面一段代码为例：
  
  1 String str="abc";2 System.out.println(str);3 str=str+"de";4 System.out.println(str);
  
  　　如果运行这段代码会发现先输出“abc”，然后又输出“abcde”，好像是str这个对象被更改了，其实，这只是一种假象罢了，JVM对于这几行代码是这样处理的，首先创建一个String对象str，并把“abc”赋值给str，然后在第三行中，其实JVM又创建了一个新的对象也名为str，然后再把原来的str的值和“de”加起来再赋值给新的str，而原来的str就会被JVM的垃圾回收机制（GC）给回收掉了，所以，str实际上并没有被更改，也就是前面说的String对象一旦创建之后就不可更改了。所以，Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。
  
  　　而StringBuilder和StringBuffer的对象是变量，对变量进行操作就是直接对该对象进行更改，而不进行创建和回收的操作，所以速度要比String快很多。
  
  　　另外，有时候我们会这样对字符串进行赋值
  
  1 String str="abc"+"de";2 StringBuilder stringBuilder=new StringBuilder().append("abc").append("de");3 System.out.println(str);4 System.out.println(stringBuilder.toString());
  
  　　这样输出结果也是“abcde”和“abcde”，但是String的速度却比StringBuilder的反应速度要快很多，这是因为第1行中的操作和
  
  String str="abcde";
  
  　　是完全一样的，所以会很快，而如果写成下面这种形式
  
  1 String str1="abc";2 String str2="de";3 String str=str1+str2;
  
  　　那么JVM就会像上面说的那样，不断的创建、回收对象来进行这个操作了。速度就会很慢。
  
  2. 再来说线程安全
  
  　　在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的
  
  　　如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中很多方法可以带有synchronized关键字，所以可以保证线程是安全的，但StringBuilder的方法则没有该关键字，所以不能保证线程安全，有可能会出现一些错误的操作。所以如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，还是建议使用速度比较快的StringBuilder。
  
  3. 总结一下
  String：适用于少量的字符串操作的情况
  
  StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
  
  StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
ArrayList和LinkedList有什么区别。
1. ArrayList和LinkedList
  
  共性：ArrayList与LinkedList都是List接口的实现类，因此都实现了List的所有未实现的方法，只是实现的方式有所不同。
  
  区别：List接口的实现方式不同
  
  ArrayList实现了List接口，以数组的方式来实现的，因此对于快速的随机取得对象的需求，使用ArrayList实现执行效率上会比较好。
  
  LinkedList是采用链表的方式来实现List接口的，因此在进行insert和remove动作时效率要比ArrayList高。适合用来实现Stack(堆栈)与Queue(队列)。
  
  HashTable和HashMap
  
  共性：都实现了Map接口。
  
  区别：
  
  (1)继承的父类不同
  
  Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。
  
  (2)线程安全性不同
  
  Hashtable的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。
  
  (3)提供contains方法
  
  HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey，因为contains方法容易让人引起误解。
  
  Hashtable则保留了contains，containsValue和containsKey三个方法，其中contains和containsValue功能相同。
  
  (4)key和value是否允许null值
  
  Hashtable中，key和value都不允许出现null值。HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。
  
  (5)两个遍历方式的内部实现上不同
  
  HashMap使用了 Iterator；Hashtable使用 Iterator，Enumeration两种方式。
  
  (6)hash值不同
  
  哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。
  
  (7)内部实现使用的数组初始化和扩容方式不同
  
  HashTable在不指定容量的情况下的默认容量为11，增加的方式是 old*2+1；而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。
讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字段，当new的时候，他们的执行顺序。
1. 此题考察的是类加载器实例化时进行的操作步骤（加载–>连接->初始化）。
  父类静态变量、
  父类静态代码块、
  子类静态变量、
  子类静态代码块、
  父类非静态变量（父类实例成员变量）、
  父类构造函数、
  子类非静态变量（子类实例成员变量）、
  子类构造函数。
2. 重温java基础，以免自己以后犯原则性错误，这是最基本，最基础的东西。
  
  直接上代码：
  
  A.java
  
  public class A {
  
  int a1 = 8;
  
  int a2 = getA2();
  
  {
  
  int a3 = 9;
  
  System.out.println("top of A() a1=" + a1 + " a2=" + a2 + " a3=" + a3);
  
  }
  
  public A() {
  
  this(66);
  
  System.out.print("A 构造函数\n");
  
  }
  
  {
  
  System.out.println("below A()..has start");
  
  }
  
  public A(int num) {
  
  System.out.print("A 带参数构造函数: " + num + "\n");
  
  }
  
  static {
  
  System.out.println("I`m a static {} from class A..");
  
  }
  
  int getA2() {
  
  System.out.println("getA2..");
  
  return 7;
  
  }
  
  public void methodA() {
  
  System.out.println("methodA");
  
  }
  
  }
  
  B.java
  
  public class B extends A {
  
  int b1 = 0;
  
  int b2 = getB2();
  
  {
  
  int b3 = 5;
  
  System.out.println("top of B() b1=" + b1 + " b2=" + b2 + " b3=" + b3);
  
  }
  
  public B() {
  
  this(33);
  
  // super(44);//添加super语句，会导致实例化时直接执行父类带参数的构造函数
  
  System.out.print("B 构造函数\n");
  
  }
  
  public B(int num) {
  
  // 添加super语句，会导致实例化时直接执行父类带参数的构造函数
  
  // 前提是带参数的构造函数B会被运行（new实例化或this）
  
  // super(77);
  
  System.out.print("B 带参数构造函数:" + num + "\n");
  
  }
  
  {
  
  System.out.println("below B()..has start");
  
  }
  
  static {
  
  System.out.println("I`m a static {} from class B..");
  
  }
  
  int getB2() {
  
  System.out.println("getB2..");
  
  return 33;
  
  }
  
  @Override
  
  public void methodA() {
  
  System.out.println("methoaA int class B");
  
  super.methodA();
  
  }
  
  }
  
  main.java
  
  public class mymain {
  
  /**
  
  * @param args
  
  */
  
  public static void main(String[] args) {
  
  // TODO Auto-generated method stub
  
  System.out.println("main app run..");
  
  B b = new B();
  
  // B b = new B(22);
  
  b.methodA();
  
  }
  
  }
  
  实验一
  
  思考一下打印输出的顺序？
  
  打印输出结果：
  
  main app run..
  
  I`m a static {} from class A..
  
  I`m a static {} from class B..
  
  getA2..
  
  top of A() a1=8 a2=7 a3=9
  
  below A()..has start
  
  A 带参数构造函数: 66
  
  A 构造函数
  
  getB2..
  
  top of B() b1=0 b2=33 b3=5
  
  below B()..has start
  
  B 带参数构造函数:33
  
  B 构造函数
  
  methoaA int class B
  
  methodA
  
  分析：B类无参的构造函数中的this语句并没有影响到父类A类的构造函数执行顺序
  
  ***********************************分割线***********************************
  
  实验二
  
  如果我把B类无参数的构造函数，this(33)换成super(44)呢，看一下结果？
  
  main app run..
  
  I`m a static {} from class A..
  
  I`m a static {} from class B..
  
  getA2..
  
  top of A() a1=8 a2=7 a3=9
  
  below A()..has start
  
  A 带参数构造函数: 44
  
  getB2..
  
  top of B() b1=0 b2=33 b3=5
  
  below B()..has start
  
  B 构造函数
  
  methoaA int class B
  
  methodA
  
  分析：B类无参构造函数中的super语句直接影响了父类（A类）构造函数的执行顺序，由于super(44)指向了父类带参数的构造函数，造成实例化时，只执行了父类带参数的构造函数，由此看出，super语句的有与无，对父类带参/不带参的构造函数是有影响的。
  
  ***********************************分割线***********************************
  
  实验三
  
  如果B类无参数的构造函数，如一开始那样this(33)保留，super去掉；但是B类带参数的构造函数添加 super(77)语句，结果又会是什么呢？
  
  main app run..
  
  I`m a static {} from class A..
  
  I`m a static {} from class B..
  
  getA2..
  
  top of A() a1=8 a2=7 a3=9
  
  below A()..has start
  
  A 带参数构造函数: 77
  
  getB2..
  
  top of B() b1=0 b2=33 b3=5
  
  below B()..has start
  
  B 带参数构造函数:33
  
  B 构造函数
  
  methoaA int class B
  
  methodA
  
  分析：B类带参数的构造函数中的super(77)，又影响了父类构造函数的执行顺序，导致父类没有执行无参的构造函数，这一切都是因为有super语句！但是请记住，因为实例化B类无参的构造函数中有一句：this(33)，使编译器看到了B类带参数构造函数中的super语句。假如说，没有this(33)语句，并且B类new时并没有new到带参数的构造函数，此时编译器并不会查找到super语句，也就继续执行父类无参的构造函数，就像实验一的结果一样。
  
  综合结论：
  
  一个类的实例化过程：
  
  1，首先会执行类中static代码块(不管代码块是否在类的开头还是末尾处)，如果这个类有父类，同样会优先查找父类中的static代码块，然后是当前类的static。
  
  2，然后会从父类的第一行开始执行，直至代码末尾处，中间不管是有赋值还是method调用，都会按顺序一一执行（method），普通代码块{ }...
  
  3，其次才是父类的构造函数，执行带参数或不带参数的构造函数，依赖于实例化的类的构造函数有没有super父类的带参或不带参的构造函数，上边试验二三已经证明。
  
  4，然后会从子类（当前类）的第一行开始执行，直至代码末尾处，中间不管是有赋值还是method调用，都会按顺序一一执行（method），普通代码块{ }...
  
  5，其次会是子类（当前类）的构造函数，按顺序执行。
  
  6，最后是类方法的调用执行，如果子类覆盖了父类的method，执行时会先执行子类覆盖的method，method内如果有super.method()，才会调用父类的同名method，否则不会。
用过哪些Map类，都有什么区别，HashMap是线程安全的吗,并发下使用的Map是什么，他们内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。
1. hashMap 异步的非线程安全的,hashtable 同步的线程安全的
JAVA8的ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计，你如何设计。
有没有有顺序的Map实现类，如果有，他们是怎么保证有序的。
1. map是键值对的集合接口，它的实现类主要包括：HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下（简单介绍）：
  
         HashMap：我们最常用的Map，它根据key的HashCode 值来存储数据,根据key可以直接获取它的Value，同时它具有很快的访问速度。HashMap最多只允许一条记录的key值为Null(多条会覆盖);允许多条记录的Value为 Null。非同步的。
  
        TreeMap: 能够把它保存的记录根据key排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
  
        Hashtable: 与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。
  
        LinkedHashMap: 保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，非同步的。
抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接口么。
1. 1、接口可以继承接口，抽象类不可以继承接口，但可以实现接口。
  
  2、抽象类可以继承实体类。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。
  
  3.抽象类可以继承实体类，就是因为抽象类的可以继承性和有方法。
  
  4、一个接口可以继承多个接口. interface C extends A, B {}是可以的. 一个类可以实现多个接口: class D implements A,B,C{} 但是一个类只能继承一个类,不能继承多个类 class B extends A{} 在继承类的同时,也可以继承接口: class E extends D implements A,B,C{} 这也正是选择用接口而不是抽象类的原因。
继承和聚合的区别在哪。
1. 聚合：
  为什么要用聚合：
  
  我们会想要一次构建两个或两个以上的项目，而不是到两个模块或是多个模块的目录下分别执行mvn命令。Maven聚合（或者称为多模块）这一特性就是为该需求服务的。
  
  继承：
  为什么要使用继承：
  
  pom.xml里面的配置，如果是多个项目，势必会出现依赖和插件的重复配置。在面向对象世界中，程序员可以使用类继承在一定程度上消除重复，在Maven的世界中，也有类似的
  
  机制能让我们抽取出重复的配置，这就是pom的继承
  
  聚合和继承的关系：
  多模块Maven项目中的聚合与继承其实是两个概念，其目的完全是不同的。前者是为了方便快速构建项目，后者是为了消除重复配置。
  
  对于聚合模块来说，他知道有哪些被聚合的模块，但是那些被聚合的模块不知道这个聚合模块的存在
  
  对于继承关系的父POM来说，他不知道有哪些子模块继承于它，但哪些子模块都必须知道自己的父POM是什么
  
  如果非要说这个两个特性的共同点，那么可以看到，聚合POM与继承关系中的父POM的packaging都必须是pom，同时，聚合模块与继承关系的父模块除了POM之外都没有实际的内容。
IO模型有哪些，讲讲你理解的nio ，他和bio，aio的区别是啥，谈谈reactor模型。
反射的原理，反射创建类实例的三种方式是什么。
1. https://blog.csdn.net/qq_23000805/article/details/89572729
反射中，Class.forName和ClassLoader区别。
1. 一 Java类装载过程
```
装载：通过累的全限定名获取二进制字节流，将二进制字节流转换成方法区中的运行时数据结构，在内存中生成Java.lang.class对象； 

链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的； 

　　校验：检查导入类或接口的二进制数据的正确性；（文件格式验证，元数据验证，字节码验证，符号引用验证） 

　　准备：给类的静态变量分配并初始化存储空间； 

　　解析：将常量池中的符号引用转成直接引用； 

初始化：激活类的静态变量的初始化Java代码和静态Java代码块，并初始化程序员设置的变量值。
```
  二分析 Class.forName()和ClassLoader.loadClass
  
  Class.forName(className)方法，内部实际调用的方法是 Class.forName(className,true,classloader); 第2个boolean参数表示类是否需要初始化， Class.forName(className)默认是需要初始化。一旦初始化，就会触发目标对象的 static块代码执行，static参数也也会被再次初始化。 ClassLoader.loadClass(className)方法，内部实际调用的方法是 ClassLoader.loadClass(className,false); 第2个 boolean参数，表示目标对象是否进行链接，false表示不进行链接，由上面介绍可以，不进行链接意味着不进行包括初始化等一些列步骤，那么静态块和静态对象就不会得到执行
  
  三 数据库链接为什么使用Class.forName(className)
  
  JDBC Driver源码如下,因此使用Class.forName(classname)才能在反射回去类的时候执行static块。static { try { java.sql.DriverManager.registerDriver(new Driver()); } catch (SQLException E) { throw new RuntimeException("Can't register driver!"); } }
描述动态代理的几种实现方式，分别说出相应的优缺点。
1. https://blog.csdn.net/qq_23000805/article/details/89573804
动态代理与cglib实现的区别。
为什么CGlib方式可以对接口实现代理。
final的用途。
写出三种单例模式实现。
如何在父类中为子类自动完成所有的hashcode和equals实现？这么做有何优劣。
请结合OO设计理念，谈谈访问修饰符public、private、protected、default在应用设计中的作用。
深拷贝和浅拷贝区别。
数组和链表数据结构描述，各自的时间复杂度。
error和exception的区别，CheckedException，RuntimeException的区别。
请列出5个运行时异常。
在自己的代码中，如果创建一个java.lang.String类，这个类是否可以被类加载器加载？为什么。
说一说你对java.lang.Object对象中hashCode和equals方法的理解。在什么场景下需
要重新实现这两个方法。
在jdk1.5中，引入了泛型，泛型的存在是用来解决什么问题。
这样的a.hashcode() 有什么用，与a.equals(b)有什么关系。
有没有可能2个不相等的对象有相同的hashcode。
Java中的HashSet内部是如何工作的。
什么是序列化，怎么序列化，为什么序列化，反序列化会遇到什么问题，如何解决。
java8的新特性。

JVM知识

什么情况下会发生栈内存溢出。
JVM的内存结构，Eden和Survivor比例。
JVM内存为什么要分成新生代，老年代，持久代。新生代中为什么要分为Eden和Survivor。
JVM中一次完整的GC流程是怎样的，对象如何晋升到老年代，说说你知道的几种主要的JVM参
数。
你知道哪几种垃圾收集器，各自的优缺点，重点讲下cms和G1，包括原理，流程，优缺点。
垃圾回收算法的实现原理。
当出现了内存溢出，你怎么排错。
JVM内存模型的相关知识了解多少，比如重排序，内存屏障，happen-before，主内存，工作
内存等。
简单说说你了解的类加载器，可以打破双亲委派么，怎么打破。
讲讲JAVA的反射机制。
你们线上应用的JVM参数有哪些。
g1和cms区别,吞吐量优先和响应优先的垃圾收集器选择。
怎么打出线程栈信息。
请解释如下jvm参数的含义：
-server -Xms512m -Xmx512m -Xss1024K
-XX:PermSize=256m -XX:MaxPermSize=512m -
XX:MaxTenuringThreshold=20XX:CMSInitiatingOccupancyFraction=80 -
XX:+UseCMSInitiatingOccupancyOnly。

开源框架知识

简单讲讲tomcat结构，以及其类加载器流程，线程模型等。
tomcat如何调优，涉及哪些参数。
讲讲Spring加载流程。
Spring AOP的实现原理。
讲讲Spring事务的传播属性。
Spring如何管理事务的。
Spring怎么配置事务（具体说出一些关键的xml 元素）。
说说你对Spring的理解，非单例注入的原理？它的生命周期？循环注入的原理，aop的实现原
理，说说aop中的几个术语，它们是怎么相互工作的。
Springmvc 中DispatcherServlet初始化过程。
netty的线程模型，netty如何基于reactor模型上实现的。
为什么选择netty。
什么是TCP粘包，拆包。解决方式是什么。
netty的fashwheeltimer的用法，实现原理，是否出现过调用不够准时，怎么解决。
netty的心跳处理在弱网下怎么办。
netty的通讯协议是什么样的。
springmvc用到的注解，作用是什么，原理。
springboot启动机制。
点击这里有一套答案版的Spring试题。

操作系统

Linux系统下你关注过哪些内核参数，说说你知道的。
Linux下IO模型有几种，各自的含义是什么。
epoll和poll有什么区别。
平时用到哪些Linux命令。
用一行命令查看文件的最后五行。
用一行命令输出正在运行的java进程。
介绍下你理解的操作系统中线程切换过程。
进程和线程的区别。
top 命令之后有哪些内容，有什么作用。
线上CPU爆高，请问你如何找到问题所在。

多线程

多线程的几种实现方式，什么是线程安全。
volatile的原理，作用，能代替锁么。
画一个线程的生命周期状态图。
sleep和wait的区别。
sleep和sleep(0)的区别。
Lock与Synchronized的区别。
synchronized的原理是什么，一般用在什么地方(比如加在静态方法和非静态方法的区别，静
态方法和非静态方法同时执行的时候会有影响吗)，解释以下名词：重排序，自旋锁，偏向锁，轻
量级锁，可重入锁，公平锁，非公平锁，乐观锁，悲观锁。
用过哪些原子类，他们的原理是什么。
JUC下研究过哪些并发工具，讲讲原理。
用过线程池吗，如果用过，请说明原理，并说说newCache和newFixed有什么区别，构造函
数的各个参数的含义是什么，比如coreSize，maxsize等。
线程池的关闭方式有几种，各自的区别是什么。
假如有一个第三方接口，有很多个线程去调用获取数据，现在规定每秒钟最多有10个线程同
时调用它，如何做到。
spring的controller是单例还是多例，怎么保证并发的安全。
用三个线程按顺序循环打印abc三个字母，比如abcabcabc。
ThreadLocal用过么，用途是什么，原理是什么，用的时候要注意什么。
如果让你实现一个并发安全的链表，你会怎么做。
有哪些无锁数据结构，他们实现的原理是什么。
讲讲java同步机制的wait和notify。
CAS机制是什么，如何解决ABA问题。
多线程如果线程挂住了怎么办。
countdowlatch和cyclicbarrier的内部原理和用法，以及相互之间的差别(比如
countdownlatch的await方法和是怎么实现的)。
对AbstractQueuedSynchronizer了解多少，讲讲加锁和解锁的流程，独占锁和公平所
加锁有什么不同。
使用synchronized修饰静态方法和非静态方法有什么区别。
简述ConcurrentLinkedQueue和LinkedBlockingQueue的用处和不同之处。
导致线程死锁的原因？怎么解除线程死锁。
非常多个线程（可能是不同机器），相互之间需要等待协调，才能完成某种工作，问怎么设计这种协调方案。
用过读写锁吗，原理是什么，一般在什么场景下用。
开启多个线程，如果保证顺序执行，有哪几种实现方式，或者如何保证多个线程都执行完
再拿到结果。
延迟队列的实现方式，delayQueue和时间轮算法的异同。
点击这里有一套答案版的多线程试题。

TCP与HTTP

http1.0和http1.1有什么区别。
TCP三次握手和四次挥手的流程，为什么断开连接要4次,如果握手只有两次，会出现什么。
TIME_WAIT和CLOSE_WAIT的区别。
说说你知道的几种HTTP响应码，比如200, 302, 404。
当你用浏览器打开一个链接（如：http://www.javastack.cn）的时候，计算机做了哪些工作步骤。
TCP/IP如何保证可靠性，说说TCP头的结构。
如何避免浏览器缓存。
如何理解HTTP协议的无状态性。
简述Http请求get和post的区别以及数据包格式。
HTTP有哪些method
简述HTTP请求的报文格式。
HTTP的长连接是什么意思。
HTTPS的加密方式是什么，讲讲整个加密解密流程。
Http和https的三次握手有什么区别。
什么是分块传送。
Session和cookie的区别。
点击这里有一套答案版的试题。

架构设计与分布式

用java自己实现一个LRU。
分布式集群下如何做到唯一序列号。
设计一个秒杀系统，30分钟没付款就自动关闭交易。
如何使用redis和zookeeper实现分布式锁？有什么区别优缺点，会有什么问题，分别适用什么
场景。（延伸：如果知道redlock，讲讲他的算法实现，争议在哪里）
如果有人恶意创建非法连接，怎么解决。
分布式事务的原理，优缺点，如何使用分布式事务，2pc 3pc 的区别，解决了哪些问题，还有
哪些问题没解决，如何解决，你自己项目里涉及到分布式事务是怎么处理的。
什么是一致性hash。
什么是restful，讲讲你理解的restful。
如何设计一个良好的API。
如何设计建立和保持100w的长连接。
解释什么是MESI协议(缓存一致性)。
说说你知道的几种HASH算法，简单的也可以。
什么是paxos算法，什么是zab协议。
一个在线文档系统，文档可以被编辑，如何防止多人同时对同
一份文档进行编辑更新。
线上系统突然变得异常缓慢，你如何查找问题。
说说你平时用到的设计模式。
Dubbo的原理，有看过源码么，数据怎么流转的，怎么实现集群，负载均衡，服务注册
和发现，重试转发，快速失败的策略是怎样的。
一次RPC请求的流程是什么。
自己实现过rpc么，原理可以简单讲讲。Rpc要解决什么问题。
异步模式的用途和意义。
编程中自己都怎么考虑一些设计原则的，比如开闭原则，以及在工作中的应用。
设计一个社交网站中的“私信”功能，要求高并发、可扩展等等。画一下架构图。
MVC模式，即常见的MVC框架。
聊下曾经参与设计的服务器架构并画图，谈谈遇到的问题，怎么解决的。
应用服务器怎么监控性能，各种方式的区别。
如何设计一套高并发支付方案，架构如何设计。
如何实现负载均衡，有哪些算法可以实现。
Zookeeper的用途，选举的原理是什么。
Zookeeper watch机制原理。
Mybatis的底层实现原理。
请思考一个方案，实现分布式环境下的countDownLatch。
后台系统怎么防止请求重复提交。
描述一个服务从发布到被消费的详细过程。
讲讲你理解的服务治理。
如何做到接口的幂等性。
如何做限流策略，令牌桶和漏斗算法的使用场景。
什么叫数据一致性，你怎么理解数据一致性。
分布式服务调用方，不依赖服务提供方的话，怎么处理服务方挂掉后，大量无效资源请求
的浪费，如果只是服务提供方吞吐不高的时候该怎么做，如果服务挂了，那么一会重启，该怎
么做到最小的资源浪费，流量半开的实现机制是什么。
dubbo的泛化调用怎么实现的，如果是你，你会怎么做。
远程调用会有超时现象，如果做到优雅的控制，JDK自带的超时机制有哪些，怎么实现的。

算法

10亿个数字里里面找最小的10个。
有1亿个数字，其中有2个是重复的，快速找到它，时间和空间要最优。
2亿个随机生成的无序整数,找出中间大小的值。
给一个不知道长度的（可能很大）输入字符串，设计一种方案，将重复的字符排重。
遍历二叉树。
有3n+1个数字，其中3n个中是重复的，只有1个是不重复的，怎么找出来。
写一个字符串（如：www.javastack.cn）反转函数。
常用的排序算法，快排，归并、冒泡。快排的最优时间复杂度，最差复杂度。冒泡排序的
优化方案。
二分查找的时间复杂度，优势。
一个已经构建好的TreeSet，怎么完成倒排序。
什么是B+树，B-树，列出实际的使用场景。
一个单向链表，删除倒数第N个数据。
200个有序的数组，每个数组里面100个元素，找出top20的元素。
单向链表，查找中间的那个元素。

数据库知识

数据库隔离级别有哪些，各自的含义是什么，MYSQL默认的隔离级别是是什么。
什么是幻读。
MYSQL有哪些存储引擎，各自优缺点。
高并发下，如何做到安全的修改同一行数据。
乐观锁和悲观锁是什么，INNODB的标准行级锁有哪2种，解释其含义。
SQL优化的一般步骤是什么，怎么看执行计划，如何理解其中各个字段的含义。
数据库会死锁吗，举一个死锁的例子，mysql怎么解决死锁。
MYsql的索引原理，索引的类型有哪些，如何创建合理的索引，索引如何优化。
聚集索引和非聚集索引的区别。
select for update 是什么含义，会锁表还是锁行或是其他。
为什么要用Btree实现，它是怎么分裂的，什么时候分裂，为什么是平衡的。
数据库的ACID是什么。
某个表有近千万数据，CRUD比较慢，如何优化。
Mysql怎么优化table scan的。
如何写sql能够有效的使用到复合索引。
mysql中in 和exists 区别。
数据库自增主键可能的问题。
MVCC的含义，如何实现的。
你做过的项目里遇到分库分表了吗，怎么做的，有用到中间件么，比如sharding jdbc等,他
们的原理知道么。
MYSQL的主从延迟怎么解决。

消息队列

消息队列的使用场景。
消息的重发，补充策略。
如何保证消息的有序性。
用过哪些MQ，和其他mq比较有什么优缺点，MQ的连接是线程安全的吗，你们公司的MQ服务
架构怎样的。
MQ系统的数据如何保证不丢失。
rabbitmq如何实现集群高可用。
kafka吞吐量高的原因。
kafka 和其他消息队列的区别，kafka 主从同步怎么实现。
利用mq怎么实现最终一致性。
使用kafka有没有遇到什么问题，怎么解决的。
MQ有可能发生重复消费，如何避免，如何做到幂等。
MQ的消息延迟了怎么处理，消息可以设置过期时间么，过期了你们一般怎么处理。

缓存

常见的缓存策略有哪些，如何做到缓存(比如redis)与DB里的数据一致性，你们项目中用到了
什么缓存系统，如何设计的。
如何防止缓存击穿和雪崩。
缓存数据过期后的更新如何设计。
redis的list结构相关的操作。
Redis的数据结构都有哪些。
Redis的使用要注意什么，讲讲持久化方式，内存设置，集群的应用和优劣势，淘汰策略等。
redis2和redis3的区别，redis3内部通讯机制。
当前redis集群有哪些玩法，各自优缺点，场景。
Memcache的原理，哪些数据适合放在缓存中。
redis和memcached 的内存管理的区别。
Redis的并发竞争问题如何解决，了解Redis事务的CAS操作吗。
Redis的选举算法和流程是怎样的。
redis的持久化的机制，aof和rdb的区别。
redis的集群怎么同步的数据的。
知道哪些redis的优化操作。
Reids的主从复制机制原理。
Redis的线程模型是什么。
请思考一个方案，设计一个可以控制缓存总体大小的自动适应的本地缓存。
如何看待缓存的使用（本地缓存，集中式缓存），简述本地缓存和集中式缓存和优缺点。
本地缓存在并发使用时的注意事项。

搜索

elasticsearch了解多少，说说你们公司es的集群架构，索引数据大小，分片有多少，以及一些
调优手段。elasticsearch的倒排索引是什么。
elasticsearch 索引数据多了怎么办，如何调优，部署。
elasticsearch是如何实现master选举的。
详细描述一下Elasticsearch索引文档的过程。
详细描述一下Elasticsearch搜索的过程。
Elasticsearch在部署时，对Linux的设置有哪些优化方法？
lucence内部结构是什么。

史上最全java全方位总结以及答案

java的基本数据类型有八种：

猜你喜欢