java面试题总结从基础到高级（吐血详细）

这些面试题包含哪些内容？
这份面试题包含了 19 个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 等。
如下图所示：

本面试题解决的痛点
稀缺性，提供真实的，覆盖面全的面试集合，包含 200+ 面试题。权威性，解决了目前市场上答案太旧甚至是错误的问题。真实性，这份面试题是企业常用的，不会偏离实际。易理解性，通俗易懂条理清晰，部分面试题包含题目解析和代码示例，让小白也能看的懂。节约时间，屏蔽无效重复信息，为真正需要面试题的人节省检索时间。
适宜阅读人群
待面试的 初/中/高级 Java 程序员查漏补缺的人想要不断完善和扩充自己 Java 技术栈的人Java 面试官限于篇幅，答案不能完全展示
扫码获取完整的 200+ Java面试题答案
面试题展示
一、Java 基础
1.JDK 和 JRE 有什么区别？
JDK是面向开发人员使用的SDK。
JRE是Java Runtime Enviroment是指baiJava的运行du环境，是面向Java程序的使用者。
Java程序必须要JRE才能运行

2.== 和 equals 的区别是什么？
"=="是判断两个变量或实例是不是指向同一个内存空间。
"equals"是判断两个变量或实例所指向的内存空间的值是不是相同。
==比较的是内存地址,是java提供的比较运算符,而equals()方法是Object中提供的方法,是可以被重写的,你也可以自己重写,所以在使用equals()方法时应该看看此类是如何重写的,仅此而已.

3.两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？
两个对象equals相等，则它们的hashcode必须相等，反之则不一定。
两个对象==相等，则其hashcode一定相等，反之不一定成立。

hashCode()是什么？
：哈希码并不是完全唯一的，它是一种算法，让同一个类的对象按照自己不同的特征尽量的有不同的哈希码，但不表示不同的对象哈希码完全不同。也有相同的情况，看程序员如何写哈希码的算法。

4.final 在 java 中有什么作用？
特征：凡是引用final关键字的地方皆不可修改！
(1)修饰类：表示该类不能被继承；
(2)修饰方法：表示方法不能被重写；
(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

5.java 中的 Math.round(-1.5) 等于多少？
Math的round方法是四舍五入,如果参数是负数,则往大的数如,Math.round(-1.5)=-1，如果是Math.round(1.5)则结果为2

6.String 属于基础的数据类型吗？
不属于。
Java8种基础的数据类型：int、short、byte、char、long、float、double、boolean。

7.java 中操作字符串都有哪些类？它们之间有什么区别？
String、StringBuffer、StringBuilder
String : final修饰，String类的方法都是返回new String。即对String对象的任何改变都不影响到原对象，对字符串的修改操作都会生成新的对象。
StringBuffer : 对字符串的操作的方法都加了synchronized，保证线程安全。
StringBuilder : 不保证线程安全，在方法体内需要进行字符串的修改操作，可以new StringBuilder对象，调用StringBuilder对象的append、replace、delete等方法修改字符串。

synchronized是什么？
在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。
同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性
synchronized的作用
Synchronized是Java中解决并发问题的一种最常用最简单的方法 ，他可以确保线程互斥的访问同步代码

8.String str="i"与 String str=new String(“i”)一样吗？ 不一样
Java 虚拟机会将其分配到常量池中，而常量池中没有重复的元素，比如当执行“张三”时，java虚拟机会先在常量池中检索是否已经有“张三”,如果有那么就将“张三”的地址赋给变量，如果没有就创建一个，然后在赋给变量；而 String z = new String(“张三”) 则会被分到堆内存中，即使内容一样还是会创建新的对象。

常量池
常量池在java用于保存在编译期已确定的，已编译的class文件中的一份数据。它包括了关于类，方法，接口等中的常量，也包括字符串常量，如String s = "java"这种申明方式；当然也可扩充，执行器产生的常量也会放入常量池，故认为常量池是JVM的一块特殊的内存空间。

9.如何将字符串反转？

1. 利用 StringBuffer 或 StringBuilder 的 reverse 成员方法:
   // StringBuffer
   public static String reverse1(String str) {
   return new StringBuilder(str).reverse().toString();
   }

2. 利用 String 的 toCharArray 方法先将字符串转化为 char 类型数组，然后将各个字符进行重新拼接:
   // toCharArray
   public static String reverse2(String str) {
   char[] chars = str.toCharArray();
   String reverse = “”;
   for (int i = chars.length - 1; i >= 0; i–) {
   reverse += chars[i];
   }
   return reverse;
   }

3. 利用 String 的 CharAt 方法取出字符串中的各个字符:
   // charAt
   public static String reverse3(String str) {
   String reverse = “”;
   int length = str.length();
   for (int i = 0; i < length; i++) {
   reverse = str.charAt(i) + reverse;
   }
   return reverse;
   }
   最后补充 main 方法中的测试代码:
   public static void main(String[] args) {
   String s = “abc123”;

   System.out.println("----------------");
   for (int i = s.length() - 1; i >= 0; i–) {
   System.out.print(s.charAt(i));
   }
   System.out.println("----------------");

   System.out.println("变换前: " + s);
   System.out.println("变换后: " + reverse1(s));
   System.out.println("变换后: " + reverse2(s));
   System.out.println("变换后: " + reverse3(s));
   }

10.String 类的常用方法都有那些？
indexOf() 返回指定字符得索引
charAt() 返回指定索引处得字符
repalce() 字符串替换
trim() 去除字符串两端的空白
split() 分割字符串 返回分割后的字符串数组
getBytes() 返回字符串的byte类型数组
length() 返回字符串的长度
toLowerCase() 字符串转小写
toUpperCase() 字符串转大写
substring() 截取字符串
equals() 字符串比较

11.抽象类必须要有抽象方法吗？
不必须
这道题考察的是抽象类的知识：
抽象类必须有关键字abstract来修饰。
抽象类可以不含有抽象方法
如果一个类包含抽象方法，则该类必须是抽象类

12.普通类和抽象类有哪些区别？

1. 普通类可以实例化,接口都不能被实例化（它没有构造方法）,抽象类如果要实例化,抽象类必须指向实现所有抽象方法的子类对象(抽象类可以直接实例化，直接重写自己的抽象方法),接口必须指向实现所有所有接口方法的类对象。
2. 抽象类要被子类继承,接口要被子类实现。
3. 接口只能做方法的声明,抽象类可以做方法的声明,也可以做方法的实现。
4. 接口里定义的变量只能是公共的静态常量,抽象类中定义的变量是普通变量。
5. 抽象类里的抽象方法必须全部被子类所实现,如果子类不能全部实现父类的抽象方法,那么该子类只能是抽象类。同样，一个实现接口的时候，如果不能全部实现接口方法，那么该类只能是抽象类。
6. 抽象方法只能声明，不能实现。接口是设计的结果，抽象类是重构的结果。
7. 抽象类里可以没有抽象方法。
8. 如果一个类里有抽象方法，那么该类只能是抽象类。
9. 抽象方法要被实现，所以不能是静态的，也不能是私有的。
10. 接口可以继承接口，并可多继承接口，但类只能单继承。（重要啊）
11. 接口中的常量：有固定的修饰符-public static final（不能用private和protected修饰/本质上都是static的而且是final类型的，不管加不加static修饰）。
12. 接口中的抽象方法：有固定的修饰符-public abstract 。
    13、接口细节：
    若接口中方法或变量没有写public，static，final / public，abstract ，会自动补齐 。
    接口中的成员都是共有的。
    接口与接口之间是继承关系，而且可以多继承。
    接口不能被实例化
    一个类可以实现多个接口
    在java开发中，我们经常把常用的变量，定义在接口中，作为全局变量使用，访问形式：接口名.变量名。
    一个接口不能继承其它的类，但是可以继承别的接口
    一个重要的原则：当一个类实现了一个接口，要求该类把这个接口的所有方法全部实现

13.抽象类能使用 final 修饰吗？
不能，抽象类是被用于继承的，final修饰代表不可修改、不可继承的。

14.接口和抽象类有什么区别？
抽象类要被子类继承，接口要被类实现。
接口只能做方法声明，抽象类中可以作方法声明，也可以做方法实现。
接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
接口是设计的结果，抽象类是重构的结果。
抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高。
抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量。
抽象类主要用来抽象类别，接口主要用来抽象功能。

15.java 中 IO 流分为几种？

16.BIO、NIO、AIO 有什么区别？
IO的方式通常分为几种：
　　同步阻塞的BIO
　　同步非阻塞的NIO
　　异步非阻塞的AIO。
　Java BIO ：
同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
　　Java NIO ：
同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
　　Java AIO(NIO.2) ：
异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，

17.Files的常用方法都有哪些？
Files.exists()：检测文件路径是否存在。
Files.createFile()：创建文件。
Files.createDirectory()：创建文件夹。
Files.delete()：删除一个文件或目录。
Files.copy()：复制文件。
Files.move()：移动文件。
Files.size()：查看文件个数。
Files.read()：读取文件。
Files.write()：写入文件。

二、容器
18.java 容器都有哪些？
JAVA的容器包括如下：
List,Map,Set ，Collection ，List ，LinkedList ，ArrayList ，Vector ，Stack ，Set
Map ，Hashtable ，HashMap ，WeakHashMap
数据容器主要分为了两类
Collection: 存放独立元素的序列。
Map：存放key-value型的元素对。（这对于需要利用key查找value的程序十分的重要！）
从类体系图中可以看出，Collection定义了Collection类型数据的最基本、最共性的功能接口，而List对该接口进行了拓展。
其中各个类的适用场景有很大的差别，在使用时，应该根据需要灵活的进行选择。此处介绍最为常用的四个容器：
LinkedList ：其数据结构采用的是链表，此种结构的优势是删除和添加的效率很高，但随机访问元素时效率较ArrayList类低。
ArrayList：其数据结构采用的是线性表，此种结构的优势是访问和查询十分方便，但添加和删除的时候效率很低。
HashSet: Set类不允许其中存在重复的元素（集），无法添加一个重复的元素（Set中已经存在）。HashSet利用Hash函数进行了查询效率上的优化，其contain（）方法经常被使用，以用于判断相关元素是否已经被添加过。
HashMap: 提供了key-value的键值对数据存储机制，可以十分方便的通过键值查找相应的元素，而且通过Hash散列机制，查找十分的方便。

19.Collection 和 Collections 有什么区别？
Collection 是集合的接口，其继承类又List Set
Collections 是集合的工具类，定义了许多操作集合的静态方法。是帮助类。

20.List、Set、Map 之间的区别是什么？
List：有序集合，元素可重复
Set：不重复集合，LinkedHashSet按照插入排序，SortedSet可排序，HashSet无序
Map：键值对集合，存储键、值和之间的映射；Key无序，唯一；value 不要求有序，允许重复

21.HashMap 和 Hashtable 有什么区别？
1.HashMap类大致相当于哈希表，但它是非同步的，并且允许空值。(HashMap允许空值作为键和值，而哈希表不允许空)。
2.主要之一HashMap与Hashtable的区别是HashMap是非同步的，而Hashtable是同步的，这意味着哈希表线程安全，可以在多个线程之间共享，但是HashMap如果没有适当的同步，就不能在多个线程之间共享。
HashMap中的迭代器是失败快速迭代器，而Hashtable的枚举器不是，如果任何其他线程通过添加或删除Iterator自己的remove()方法之外的任何元素在结构上修改映射，则抛出ConcurrentModificationException。但是这不是一种有保证的行为，JVM将尽最大努力来完成。这也是Java中枚举和迭代器之间的一个重要区别。

22.如何决定使用 HashMap 还是 TreeMap？
TreeMap的实现是基于红黑树结构。适用于按自然顺序或自定义顺序遍历键（key）。
HashMap<K,V>的Key值实现散列hashCode()，分布是散列的、均匀的，不支持排序；数据结构主要是桶(数组)，链表或红黑树。适用于在Map中插入、删除和定位元素。
如果你需要得到一个有序的结果时就应该使用TreeMap（因为HashMap中元素的排列顺序是不固定的）。除此之外，由于HashMap有更好的性能，所以大多不需要排序的时候我们会使用HashMap。

23.说一下 HashMap 的实现原理？
HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

24.说一下 HashSet 的实现原理？
HashSet 的父类接口是Set集合
HashSet 是以Hash表结构存储
HashSet 多线程不安全
HashMap 可以存null值，
HashSet的底层是用HashMap实现的，将HashMap 值的那一列隐藏，就是HashSet （存在键的那一列）
一般子类需要用到HashCode方法，并且进行重写。

25.ArrayList 和 LinkedList 的区别是什么？
数据结构实现：
ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。
• 随机访问效率：
ArrayList 比 LinkedList 在随机访问的时候效率要高，
因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找。
• 增加和删除效率：
在非首尾的增加和删除操作，LinkedList 要比 ArrayList 效率要高，
因为 ArrayList 增删操作要影响数组内的其他数据的下标。
• 综合来说：
在需要频繁读取集合中的元素时，更推荐使用 ArrayList，
而在插入和删除操作较多时，更推荐使用 LinkedList。

26.如何实现数组和 List 之间的转换？
数组转 List ，使用 JDK 中 java.util.Arrays 工具类的 asList 方法

public static void testArray2List() {
String[] strs = new String[] {“aaa”, “bbb”, “ccc”};
List list = Arrays.asList(strs);
for (String s : list) {
System.out.println(s);
}
}
List 转数组，使用 List 的toArray方法。无参toArray方法返回Object数组，传入初始化长度的数组对象，返回该对象数组
public static void testList2Array() {
List list = Arrays.asList(“aaa”, “bbb”, “ccc”);
String[] array = list.toArray(new String[list.size()]);
for (String s : array) {
System.out.println(s);
}
}

27.ArrayList 和 Vector 的区别是什么？
线程安全：Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而 ArrayList 是非线程安全的。
性能：ArrayList 在性能方面要优于 Vector。
扩容：ArrayList 和 Vector 都会根据实际的需要动态的调整容量，
只不过在 Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%。

28.Array 和 ArrayList 有何区别？
Array 即数组，声明方式可以如下：
定义一个 Array 时，必须指定数组的数据类型及数组长度，即数组中存放的元素个数固定并且类型相同。
ArrayList 是动态数组，长度动态可变，会自动扩容。不使用泛型的时候，可以添加不同类型元素。

29.在 Queue 中 poll()和 remove()有什么区别？
在 Queue 中 poll()和 remove()有什么区别？
1、offer()和add()的区别
add()和offer()都是向队列中添加一个元素。但是如果想在一个满的队列中加入一个新元素，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。可以据此在程序中进行有效的判断！
2、peek()和element()的区别
peek()和element()都将在不移除的情况下返回队头，但是peek()方法在队列为空时返回null，调用element()方法会抛出NoSuchElementException异常。
3、poll()和remove()的区别
poll()和remove()都将移除并且返回对头，但是在poll()在队列为空时返回null，而remove()会抛出NoSuchElementException异常。
笔者在此总结，希望对大家有所帮助！

30.哪些集合类是线程安全的？
下面举一些常用的功能相同却线程安全和不安全的集合。
Vector：就比Arraylist多了个同步化机制（线程安全）。
Hashtable：就比Hashmap多了个线程安全。
ConcurrentHashMap:是一种高效但是线程安全的集合。
Stack：栈，也是线程安全的，继承于Vector。

31.迭代器 Iterator 是什么？
首先说一下迭代器模式，它是 Java 中常用的设计模式之一。用于顺序访问集合对象的元素，无需知道集合对象的底层实现。
Iterator 是可以遍历集合的对象，为各种容器提供了公共的操作接口，隔离对容器的遍历操作和底层实现，从而解耦。
缺点是增加新的集合类需要对应增加新的迭代器类，迭代器类与集合类成对增加。

32.Iterator 怎么使用？有什么特点？
java.lang.Iterable 接口被 java.util.Collection 接口继承，java.util.Collection 接口的 iterator() 方法返回一个 Iterator 对象
next() 方法获得集合中的下一个元素
hasNext() 检查集合中是否还有元素
remove() 方法将迭代器新返回的元素删除
forEachRemaining(Consumer<? super E> action) 方法，遍历所有元素
public class TestIterator {

static List<String> list = new ArrayList<String>();

static {
    list.add("111");
    list.add("222");
    list.add("333");
}


public static void main(String[] args) {
    testIteratorNext();
    System.out.println();
    
    testForEachRemaining();
    System.out.println();
    
    testIteratorRemove();
}

//使用 hasNext 和 next遍历 
public static void testIteratorNext() {
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String str = iterator.next();
        System.out.println(str);
    }
}

//使用 Iterator 删除元素 
public static void testIteratorRemove() {
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String str = iterator.next();
        if ("222".equals(str)) {
            iterator.remove();
        }
    }
    System.out.println(list);
}

//使用 forEachRemaining 遍历
public static void testForEachRemaining() {
    final Iterator<String> iterator = list.iterator();
    iterator.forEachRemaining(new Consumer<String>() {

        public void accept(String t) {
            System.out.println(t);
        }
        
    });
}

}

33.Iterator 和 ListIterator 有什么区别？
ListIterator 继承 Iterator
ListIterator 比 Iterator多方法
1） add(E e) 将指定的元素插入列表，插入位置为迭代器当前位置之前
2） set(E e) 迭代器返回的最后一个元素替换参数e
3） hasPrevious() 迭代器当前位置，反向遍历集合是否含有元素
4） previous() 迭代器当前位置，反向遍历集合，下一个元素
5） previousIndex() 迭代器当前位置，反向遍历集合，返回下一个元素的下标
6） nextIndex() 迭代器当前位置，返回下一个元素的下标
使用范围不同，Iterator可以迭代所有集合；ListIterator 只能用于List及其子类
ListIterator 有 add 方法，可以向 List 中添加对象；Iterator 不能
ListIterator 有 hasPrevious() 和 previous() 方法，可以实现逆向遍历；Iterator不可以
ListIterator 有 nextIndex() 和previousIndex() 方法，可定位当前索引的位置；Iterator不可以
ListIterator 有 set()方法，可以实现对 List 的修改；Iterator 仅能遍历，不能修改

34.怎么确保一个集合不能被修改？
三、多线程
35.并行和并发有什么区别？
并发（concurrency）和并行（parallellism）是：
解释一：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。
解释二：并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。
解释三：在一台处理器上“同时”处理多个任务，在多台处理器上同时处理多个任务。如hadoop分布式集群
所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。

36.线程和进程的区别？
进程是并发执行的程序在执行过程中分配和管理资源的基本单位。线程是进程的一个执行单元，是比进程还要小的独立运行的基本单位。一个程序至少有一个进程，一个进程至少有一个线程。
进程是资源分配最小单位，线程是程序执行的最小单位。

37.守护线程是什么？
守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程，这是它的作用——而其他的线程只有一种，那就是用户线程。所以java里线程分2种，
1、守护线程，比如垃圾回收线程，就是最典型的守护线程。
2、用户线程，就是应用程序里的自定义线程。

38.创建线程有哪几种方式？
一、继承Thread类创建线程类
（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该线程。

39.说一下 runnable 和 callable 有什么区别？
Callable接口
public interface Callable {
V call() throws Exception;
}
Runnable接口
public interface Runnable {
public abstract void run();
}
Runnable和Callable的区别
相同点
1、两者都是接口；（废话）
2、两者都可用来编写多线程程序；
3、两者都需要调用Thread.start()启动线程；
不同点
1、两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
2、Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；

40.线程有哪些状态？
线程有6个状态。
这6个状态分别是：New, Runnable, Blocked, Waiting, Timed_Waiting, Terminated.
NEW ：尚未启动的线程处于此状态
RUNNABLE ：在Java虚拟机中执行的线程处于这种状态
BLOCKED：等待监视器锁定被阻止的线程处于此状态。
WAITING ：无限期等待另一线程执行特定操作的线程处于此状态。TIMED_WAITING： 在指定等待时间内等待另一线程执行操作的线程处于此状态。
TERMINATED ：已退出的线程处于此状态

41.sleep() 和 wait() 有什么区别？
sleep()和wait()都是线程暂停执行的方法。
1、这两个方法来自不同的类分别是Thread和Object，sleep方法属于Thread类中的静态方法，wait属于Object的成员方法。
2、sleep()是线程类（Thread）的方法，不涉及线程通信，调用时会暂停此线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复；wait()是Object的方法，用于线程间的通信，调用时会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才进入对象锁定池准备获得对象锁进入运行状态。
3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）。
4、sleep()方法必须捕获异常InterruptedException，而wait()\notify()以及notifyAll()不需要捕获异常。
注意：
　　sleep方法只让出了CPU，而并不会释放同步资源锁。
　　线程执行sleep()方法后会转入阻塞状态。
　　sleep()方法指定的时间为线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。
　　notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度。

42.notify()和 notifyAll()有什么区别？
1、notify()只能唤醒一个wait()线程，然而notifyAll()可以唤醒多个wait()线程；
2、两个都必须在synchronized中使用，过程不释放锁；
3、当每个线程都有特定锁的时候，只有等待这个锁的线程才能被唤醒，也就是线程2的notify()或notifyAll()不能唤醒线程1的wait()；

43.线程的 run()和 start()有什么区别？
调用 start() 方法是用来启动线程的，轮到该线程执行时，会自动调用 run()；直接调用 run() 方法，无法达到启动多线程的目的，相当于主线程线性执行 Thread 对象的 run() 方法。
一个线程对线的 start() 方法只能调用一次，多次调用会抛出 java.lang.IllegalThreadStateException 异常；run() 方法没有限制。

44.创建线程池有哪几种方式？
通过Executors工厂方法创建
通过new ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)自定义创建
1、newCachedThreadPool（），它是用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置时间超过60秒，则被终止并移除缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用SynchronousQueue作为工作队列。
2、newFixedThreadPool（int nThreads），重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，任何时候最多有nThreads个工作线程是活动的。这意味着，如果任务数量超过了活动线程数目，将在工作队列中等待空闲线程出现；如果工作线程退出，将会有新的工作线程被创建，以补足指定数目nThreads。
3、newSingleThreadExecutor()，它的特点在于工作线程数目限制为1，操作一个无界的工作队列，所以它保证了所有的任务都是被顺序执行，最多会有一个任务处于活动状态，并且不予许使用者改动线程池实例，因此可以避免改变线程数目。
4、newSingleThreadScheduledExecutor()和newScheduledThreadPool(int corePoolSize)，创建的是个ScheduledExecutorService，可以进行定时或周期性的工作调度，区别在于单一工作线程还是多个工作线程。
5、newWorkStealingPool(int parallelism)，这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序。

45.线程池都有哪些状态？
1.RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。线程池的初始化状态是RUNNING。线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0。
2.SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。调用线程池的shutdown()方法时，线程池由RUNNING -> SHUTDOWN。
3.STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。调用线程池的shutdownNow()方法时，线程池由(RUNNING or SHUTDOWN ) -> STOP。
4.TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。因为terminated()在ThreadPoolExecutor类中是空的，所以用户想在线程池变为TIDYING时进行相应的处理；可以通过重载terminated()函数来实现。
当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。
5.TERMINATED：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

46.线程池中 submit()和 execute()方法有什么区别？
execute() 参数 Runnable ；submit() 参数 (Runnable) 或 (Runnable 和 结果 T) 或 (Callable)
execute() 没有返回值；而 submit() 有返回值
submit() 的返回值 Future 调用get方法时，可以捕获处理异常

47.在 java 程序中怎么保证多线程的运行安全？
线程的安全性问题体现在：
原子性：一个或者多个操作在 CPU 执行的过程中不被中断的特性
可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到
有序性：程序执行的顺序按照代码的先后顺序执行
导致原因：
缓存导致的可见性问题
线程切换带来的原子性问题
编译优化带来的有序性问题
解决办法：
JDK Atomic开头的原子类、synchronized、LOCK，可以解决原子性问题
synchronized、volatile、LOCK，可以解决可见性问题
Happens-Before 规则可以解决有序性问题

48.多线程锁的升级原理是什么？
49.什么是死锁？
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。”

50.怎么防止死锁？
只要打破四个必要条件之一就能有效预防死锁的发生：打破互斥条件：改造独占性资源为虚拟资源，大部分资源已无法改造。打破不可抢占条件：当一进程占有一独占性资源后又申请一独占性资源而无法满足，则退出原占有的资源。打破占有且申请条件：采用资源预先分配策略，即进程运行前申请全部资源，满足则运行，不然就等待，这样就不会占有且申请。打破循环等待条件：实现资源有序分配策略，对所有设备实现分类编号，所有进程只能采用按序号递增的形式申请资源。

51.ThreadLocal 是什么？有哪些使用场景？
ThreadLocal 是线程本地存储，在每个线程中都创建了一个 ThreadLocalMap 对象，每个线程可以访问自己内部 ThreadLocalMap 对象内的 value。
经典的使用场景是为每个线程分配一个 JDBC 连接 Connection。这样就可以保证每个线程的都在各自的 Connection 上进行数据库的操作，不会出现 A 线程关了 B线程正在使用的 Connection； 还有 Session 管理 等问题。

52.说一下 synchronized 底层实现原理？
53.synchronized 和 volatile 的区别是什么？
volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

54.synchronized 和 Lock 有什么区别？
1.原始构成
synchronized是关键字属于jvm层面
monitorenter(底层是通过monitor对象来完成的，其实wait/notify等方法也依赖于monitor对象，只有在同步块或方法中才能调用wait/notify等方法)
monitorexit
Lock是具体类（java.util.concurrent.locks.lock）是api层面的锁
2.使用方法
synchronized不需要用户去手动释放锁，当synchronized代码执行完后自动让线程释放对锁的占用！
Reentrantlock则需要用户手动释放锁，就有可能出现死锁现象。
需要lock()和unlock()方法配合try/finally语句块来完成。
3.等待是否可中断
synchronized不可中断，除非抛出异常或者正常完成
Reentrantlock可中断，1.设置超时方法 tryLock(long timeout,TimeUnit unit)
2.lockInterruptibly()放代码块中，调用interrupt（）方法可中断
4.加锁是否公平
synchronized非公平锁
Reentrantlock 两者都可以，默认非公平锁
5.锁绑定多个条件Condition
synchronized没有
ReentrantLock用来实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像synchronized要么随机唤醒一个要么唤醒全部线程。

55.synchronized 和 ReentrantLock 区别是什么？
synchronized 竞争锁时会一直等待；ReentrantLock 可以尝试获取锁，并得到获取结果
synchronized 获取锁无法设置超时；ReentrantLock 可以设置获取锁的超时时间
synchronized 无法实现公平锁；ReentrantLock 可以满足公平锁，即先等待先获取到锁
synchronized 控制等待和唤醒需要结合加锁对象的 wait() 和 notify()、notifyAll()；ReentrantLock 控制等待和唤醒需要结合 Condition 的 await() 和 signal()、signalAll() 方法
synchronized 是 JVM 层面实现的；ReentrantLock 是 JDK 代码层面实现
synchronized 在加锁代码块执行完或者出现异常，自动释放锁；ReentrantLock 不会自动释放锁，需要在 finally{} 代码块显示释放
PS：
补充一个相同点：都可以做到同一线程，同一把锁，可重入代码块。

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

58.什么是 java 序列化？什么情况下需要序列化？
序列化：将 Java 对象转换成字节流的过程。
反序列化：将字节流转换成 Java 对象的过程。
当 Java 对象需要在网络上传输 或者 持久化存储到文件中时，就需要对 Java 对象进行序列化处理。
序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。
注意事项：
某个类可以被序列化，则其子类也可以被序列化
声明为 static 和 transient 的成员变量，不能被序列化。static 成员变量是描述类级别的属性，transient 表示临时数据
反序列化读取序列化对象的顺序要保持一致

59.动态代理是什么？有哪些应用？
动态代理：当想要给实现了某个接口的类中的方法，加一些额外的处理。比如说加日志，加事务等。可以给这个类创建一个代理，故名思议就是创建一个新的类，这个类不仅包含原来类方法的功能，而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的，是动态生成的。具有解耦意义，灵活，扩展性强。
动态代理实现：首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回。
动态代理的应用：Spring的AOP，加事务，加权限，加日志。

60.怎么实现动态代理？
Java领域中，常用的动态代理实现方式有两种，一种是利用JDK反射机制生成代理，另外一种是使用CGLIB代理。

五、对象拷贝
61.为什么要使用克隆？
想对一个对象进行处理，又想保留原有的数据进行接下来的操作，就需要克隆了。
克隆分浅克隆和深克隆，浅克隆后的对象中非基本对象和原对象指向同一块内存，因此对这些非基本对象的修改会同时更改克隆前后的对象。深克隆可以实现完全的克隆，可以用反射的方式或序列化的方式实现。

62.如何实现对象克隆？
有两种方式：
1). 实现Cloneable接口并重写Object类中的clone()方法；
2). 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克

63.深拷贝和浅拷贝区别是什么？
浅拷贝：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针，不复制堆内存中的对象。
深拷贝：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针和堆内存中的对象。

六、Java Web
64.jsp 和 servlet 有什么区别？
65.jsp 有哪些内置对象？作用分别是什么？
66.说一下 jsp 的 4 种作用域？
67.session 和 cookie 有什么区别？
68.说一下 session 的工作原理？
69.如果客户端禁止 cookie 能实现 session 还能用吗？
70.spring mvc 和 struts 的区别是什么？
71.如何避免 sql 注入？
72.什么是 XSS 攻击，如何避免？
73.什么是 CSRF 攻击，如何避免？
七、异常
74.throw 和 throws 的区别？
throw：
表示方法内抛出某种异常对象
如果异常对象是非 RuntimeException 则需要在方法申明时加上该异常的抛出 即需要加上 throws 语句 或者 在方法体内 try catch 处理该异常，否则编译报错
执行到 throw 语句则后面的语句块不再执行
throws：
方法的定义上使用 throws 表示这个方法可能抛出某种异常
需要由方法的调用者进行异常处理

75.final、finally、finalize 有什么区别？
一、final ：
1、修饰符（关键字） 如果一个类被声明为final,意味着它不能再派生新的子类，不能作为父类被继承。因此一个类不能及被声明为abstract，又被声明为final的。
2、将变量或方法声明为final,可以保证他们使用中不被改变。被声明为final的变量必须在声明时给定初值，而以后的引用中只能读取，不可修改，被声明为final的方法也同样只能使用，不能重载。
二、finally:
在异常处理时提供finally块来执行清楚操作。如果抛出一个异常，那么相匹配的catch语句就会执行，然后控制就会进入finally块，如果有的话。
三、finalize：
是方法名。java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除之前做必要的清理工作。这个方法是在垃圾收集器在确定了，被清理对象没有被引用的情况下调用的。
finalize是在Object类中定义的，因此，所有的类都继承了它。子类可以覆盖finalize()方法，来整理系统资源或者执行其他清理工作。

76.try-catch-finally 中哪个部分可以省略？
catch 和 finally 语句块可以省略其中一个，否则编译会报错。

77.try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？
会执行，在return 前执行

78.常见的异常类有哪些？
(1)NullPointerException 当应用程序试图访问空对象时，则抛出该异常。
(2)SQLException 提供关于数据库访问错误或其他错误信息的异常。
(3)IndexOutOfBoundsException指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
(4)NumberFormatException当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
(5)FileNotFoundException当试图打开指定路径名表示的文件失败时，抛出此异常。
(6)IOException当发生某种I/O异常时，抛出此异常。此类是失败或中断的I/O操作生成的异常的通用类。
(7)ClassCastException当试图将对象强制转换为不是实例的子类时，抛出该异常。
(8)ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常。
(9)IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。
(10)ArithmeticException当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。
(11)NegativeArraySizeException如果应用程序试图创建大小为负的数组，则抛出该异常。
(12)NoSuchMethodException无法找到某一特定方法时，抛出该异常。
(13)SecurityException由安全管理器抛出的异常，指示存在安全侵犯。
(14)UnsupportedOperationException当不支持请求的操作时，抛出该异常。
(15)RuntimeExceptionRuntimeException 是那些可能在Java虚拟机正常运行期间抛出的异常的超类。

八、网络
79.http 响应码 301 和 302 代表的是什么？有什么区别？
301 Moved Permanently
被请求的资源已永久移动到新位置，并且将来任何对此资源的引用都应该使用本响应返回的若干个 URI 之一。如果可能，拥有链接编辑功能的客户端应当自动把请求的地址修改为从服务器反馈回来的地址。除非额外指定，否则这个响应也是可缓存的。
302 Found
请求的资源现在临时从不同的 URI 响应请求。由于这样的重定向是临时的，客户端应当继续向原有地址发送以后的请求。只有在Cache-Control或Expires中进行了指定的情况下，这个响应才是可缓存的。

80.forward 和 redirect 的区别？
1、请求方不同
redirect：客户端发起的请求
forward：服务端发起的请求
2、浏览器地址表现不同
redirect：浏览器地址显示被请求的
urlforward：浏览器地址不显示被请求的url
3、参数传递不同
redirect：重新开始一个request,原页面的request生命周期结束。
forward：forward另一个连接的时候。request变量是在其生命周期内的。另一个页面也可以使用，其实质是把目标地址include。
4、底层运作不同
redirect：发送的请求信息又回送给客户机，让客户机再转发到另一个资源上，需要在服务器和客户机之间增加一次通信。
forward：服务器端直接找到目标，并include过来。
5、定义不同
直接转发方式（Forward）：客户端和浏览器只发出一次请求，Servlet、HTML、JSP或其它信息资源，由第二个信息资源响应该请求，在请求对象request中，保存的对象对于每个信息资源是共享的。
间接转发方式（Redirect）实际是两次HTTP请求，服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的。

81.简述 tcp 和 udp的区别？
TCP面向连接，而UDP是无连接的，也就是说，UDP发送数据前不需要建立连接；
其次，TCP提供的服务更可靠，换句话说，通过TCP连接传输的数据无差错、不丢失、不重复，并且能够按序到达，而UDP不保证可靠交付；
第三，TCP面向字节流，也就是说TCP处理数据时，看成一连串无结构的字节流，而UDP则面向报文的，TCP连接只能是点到点的，但UDP不但支持一对一，还可以一对多、多对一和多对多的交互通信，UDP的首部开销8个字节比TCP的20字节要小。

82.tcp 为什么要三次握手，两次不行吗？为什么？
两次握手只能保证单向连接是畅通的。只有经过第三次握手，才能确保双向都可以接收到对方的发送的数据

83.说一下 tcp 粘包是怎么产生的？
1.发送方产生粘包
采用TCP协议传输数据的客户端与服务器经常是保持一个长连接的状态（一次连接发一次数据不存在粘包），双方在连接不断开的情况下，可以一直传输数据；但当发送的数据包过于的小时，那么TCP协议默认的会启用Nagle算法，将这些较小的数据包进行合并发送（缓冲区数据发送是一个堆压的过程）；这个合并过程就是在发送缓冲区中进行的，也就是说数据发送出来它已经是粘包的状态了；

---

2.接收方产生粘包
接收方采用TCP协议接收数据时的过程是这样的：数据到底接收方，从网络模型的下方传递至传输层，传输层的TCP协议处理是将其放置接收缓冲区，然后由应用层来主动获取（C语言用recv、read等函数）；这时会出现一个问题，就是我们在程序中调用的读取数据函数不能及时的把缓冲区中的数据拿出来，而下一个数据又到来并有一部分放入的缓冲区末尾，等我们读取数据时就是一个粘包；（放数据的速度 > 应用层拿数据速度）

84.OSI 的七层模型都有哪些？
OSI模型分为七层，自下而上为 物理层（Physical Layer）、数据链路层（Data Link Layer）、网络层（Network Layer）、传输层（Transport Layer）、会话层（Session Layer）、表达层（Presentation Layer）、应用层（Application Layer）。

85.get 和 post 请求有哪些区别？
GET把参数包含在URL中，POST通过request body传递参数。

86.如何实现跨域？
跨域：当浏览器执行脚本时会检查是否同源，只有同源的脚本才会执行，如果不同源即为跨域。
这里的同源指访问的协议、域名、端口都相同。
同源策略是由 Netscape 提出的著名安全策略，是浏览器最核心、基本的安全功能，它限制了一个源中加载脚本与来自其他源中资源的交互方式。
Ajax 发起的跨域 HTTP 请求，结果被浏览器拦截，同时 Ajax 请求不能携带与本网站不同源的 Cookie。