JavaSE基础面试题（全面整理版）

1.JDK 和 JRE 有什么区别？

JDK是Java的开发工具，它不仅提供了Java程序运行所需的JRE，还提供了一系列的编译，运行等工具，如javac，java，javaw等。
JRE只是Java程序的运行环境，它最核心的内容就是JVM（Java虚拟机）及核心类库。

2.== 和 equals 的区别是什么？

==号比较的是内存地址
equals()比较的是字符串的内容

3.两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？

不一定。同时反过来equals为true，hashCode也不一定相同。
hashCode()返回该对象的哈希码值；equals()返回两个对象内容是否相等。

4.final 在 java 中有什么作用？

	// final 修饰的类不能被继承，常用于修饰工具类，不允许第三方修改使用
	final class tools { 
	    String tool;
	}
	
	class A {
	   final boolean name = false; 
	   // final 修饰的变量变成常量，只能被赋值一次(基本类型)
	   final int age;
	   {
	   // final 修饰的变量可在构造方法或构造代码块内初始化
	       age = 21; 
	   }   
	   // final 修饰的方法不能被重写，但可以重载
	 final void method() { 
	     System.out.println("final method");
	 }
	}

class B extends A {
    String gender;
    // 错误写法，重写父类中的方法
    // public void method() {
    //      
    // }
     
     // 允许重载被final修饰的方法
    public void method(String gender) {
        this.gender = gender;
    }
}

    public class Demo1 {
    public static void main(String[] args) {
   // final 修饰引用类型，地址值仅赋值一次且不能改变，但对象属性值可以改变
        final B b = new B(); 
        // b = new B(); error
        b.gender = "男";
        System.out.println(b.gender);
    }
}

5.java 中的 Math.round(-1.5) 等于多少？

原则：同时向正无穷方向取舍，取较大的值 -1

6.String 属于基础的数据类型吗？

• 基本数据类型如下
  
• 引用数据类型：数组、接口、对象
• String类

  String类并不是基本数据类，而是一个类（class），是java等编程语言中的字符串。
  String类是不可变的，对String类的任何改变，都是返回一个新的String类对象。
  String 对象是 System.Char 对象的有序集合，用于表示字符串。
  String 对象的值是该有序集合的内容，并且该值是不可变的。

7.java 中操作字符串都有哪些类？它们之间有什么区别？

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

8.String str="i"与 String str=new String(“i”)一样吗？

不一样。前者是一个常量，后者又重新new了一个对象，内存空间不一样

9.如何将字符串反转？

https://blog.csdn.net/cghu1201/article/details/78490934

10.String 类的常用方法都有那些？

https://blog.csdn.net/qq_25406669/article/details/79021911

11.抽象类必须要有抽象方法吗？

1.抽象类可以没有抽象方法，但是如果你的一个类已经声明成了抽象类，即使这个类中没有抽象方法，它也不能再实例化，即不能直接构造一个该类的对象。
2.如果一个类中有了一个抽象方法，那么这个类必须声明为抽象类，否则编译通不过。

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

1.抽象类不能被实例化。
2.抽象类可以有构造函数，被继承时子类必须继承父类一个构造方法，抽象方法不能被声明为静态。
3.抽象方法只需申明，而无需实现，抽象类中可以允许普通方法有主体
4.含有抽象方法的类必须申明为抽象类
5.抽象的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类
6.抽象类是否可以有构造函数？
答案是可以有。抽象类的构造函数用来初始化抽象类的一些字段，而这一切都在抽象类的派生类实例化之前发生。不仅如此，抽线类的构造函数还有一种巧妙应用：就是在其内部实现子类必须执行的代码

13.抽象类能使用 final 修饰吗？

Java抽象类不可以被 final修饰，抽象类需要被继承才能使用，而被final修饰的类无法被继承，所以abstract和final是不能共存的。

14.接口和抽象类有什么区别？

(1) 抽象类可以有构造方法，接口中不能有构造方法。
(2) 抽象类中可以有普通成员变量，接口中没有普通成员变量
（3）抽象类中可以包含静态方法，接口中不能包含静态方法
（4） 一个类可以实现多个接口，但只能继承一个抽象类。
（5）接口可以被多重实现，抽象类只能被单一继承
（6）如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法

15.java 中 IO 流分为几种？

• 按流向分（站在程序角度考虑）
  输入流(input)
  输出流(output)

• 按类型分:

  字节流(InputStream/OutputStream)
  任何文件都可以通过字节流进行传输。

  字符流(Reader/Writer)
  非纯文本文件，不能用字符流，会导致文件格式破坏，不能正常执行。

  节点流(低级流:直接跟输入输出源对接)
  FileInputStream/FileOutputStream/FileReader/FileWriter/PrintStream/PrintWriter.

  处理流(高级流:建立在低级流的基础上)
  转换流：InputStreamReader/OutputStreamWriter，字节流转字符流/字符流转字节流
  缓冲流：BufferedInputStream/BufferedOutputStream BufferedReader/BufferedReader可对节点流经行包装，使读写更快

16.BIO、NIO、AIO 有什么区别？

Java BIO ： 同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。

Java NIO ： 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

Java AIO(NIO.2) ： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，

17.Files的常用方法都有哪些？

创建
createNewFile()在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。
mkdir() 在指定位置创建一个单级文件夹。
mkdirs() 在指定位置创建一个多级文件夹。
renameTo(File dest)如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名,如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。

删除：
delete()删除文件或者一个空文件夹，不能删除非空文件夹，马上删除文件，返回一个布尔值。
deleteOnExit()jvm退出时删除文件或者文件夹，用于删除临时文件，无返回值。

判断：
exists() 文件或文件夹是否存在。
isFile() 是否是一个文件，如果不存在，则始终为false。
isDirectory() 是否是一个目录，如果不存在，则始终为false。
isHidden() 是否是一个隐藏的文件或是否是隐藏的目录。
isAbsolute() 测试此抽象路径名是否为绝对路径名。

获取：
getName() 获取文件或文件夹的名称，不包含上级路径。
getAbsolutePath()获取文件的绝对路径，与文件是否存在没关系
length()获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。
getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。
lastModified()获取最后一次被修改的时间。

文件夹相关：
static File[] listRoots()列出所有的根目录（Window中就是所有系统的盘符）
list() 返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。
listFiles() 返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。
list(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
listFiles(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

18.java 容器都有哪些？

19.Collection 和 Collections 有什么区别？

java.util.Collection是一个集合接口（集合类的一个顶级接口）。
它提供了对集合对象进行基本操作的通用接口方法。
Collection接口在Java 类库中有很多具体的实现。
Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式
其直接继承接口有List与Set。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set

java.util.Collections 是一个包装类（工具类/帮助类）。
它包含有各种有关集合操作的静态多态方法。
此类不能实例化，就像一个工具类，用于对集合中元素进行排序、
搜索以及线程安全等各种操作，服务于Java的Collection框架。

20.List、Set、Map 之间的区别是什么？

List(列表)
 List的元素以线性方式存储，可以存放重复对象，List主要有以下两个实现类：
ArrayList : 长度可变的数组，可以对元素进行随机的访问，向ArrayList中插入与删除元素的速度慢。
JDK8 中ArrayList扩容的实现是通过grow()方法里使用语句
newCapacity = oldCapacity + (oldCapacity >> 1)（即1.5倍扩容）计算容量，
然后调用Arrays.copyof()方法进行对原数组进行复制。
LinkedList: 采用链表数据结构，插入和删除速度快，但访问速度慢。

Set(集合)
  Set中的对象不按特定(HashCode)的方式排序，并且没有重复对象，Set主要有以下两个实现类：
HashSet： HashSet按照哈希算法来存取集合中的对象，存取速度比较快。
当HashSet中的元素个数超过数组大小*loadFactor（默认值为0.75）时，
就会进行近似两倍扩容（newCapacity = (oldCapacity << 1) + 1）。
TreeSet：TreeSet实现了SortedSet接口，能够对集合中的对象进行排序。

Map(映射)
Map是一种把键对象和值对象映射的集合，它的每一个元素都包含一个键对象和值对象。Map主要有以下两个实现类：
HashMap：HashMap基于散列表实现，其插入和查询的开销是固定的，可以通过构造器设置容量和负载因子来调整容器的性能。
LinkedHashMap：类似于HashMap，但是迭代遍历它时，取得的顺序是其插入次序， 或者是最近最少使用(LRU)的次序。
TreeMap：TreeMap基于红黑树实现。查看时，它们会被排序。TreeMap是唯一的带有subMap()方法的Map，subMap()可以返回一个子树。

21.HashMap 和 Hashtable 有什么区别？

Hashtable、HashMap、TreeMap都是最常见的Map接口的实现，是以键值对的形式存储和操作数据的容器类型。

Hashtable是早期Java类库提供的一个哈希表实现，本身是线程安全的，不支持null键和值。由于线程安全导致的性能开销，所以已经很少被推荐使用。

HashMap是应用更加广泛的哈希表实现，行为上大致与Hashtable一致，主要区别在于HashMap不是线程安全的，且支持null键和值等。通常情况下，HashMap进行put或者get操作，可以达到常数时间的性能，所以它是绝大部分利用键值对存取场景的首选。

TreeMap则是基于红黑树的一种提供顺序访问的Map，和HashMap不同，它的get、put、remove之类操作都是O(log(n))的时间复杂度，具体顺序可以由指定的Comparator来决定，或者根据键的自然顺序来判断。

22.如何决定使用 HashMap 还是 TreeMap？

Map	使用情况	原因
HashMap	查询	基于散列表实现（推荐作为常规Map使用）
TreeMap	增加、快速创建	基于红黑树实现

23.说一下 HashMap 的实现原理？

HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度依然为O(1)，因为最新的Entry会插入链表头部，急需要简单改变引用链即可，而对于查找操作来讲，此时就需要遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

24.说一下 HashSet 的实现原理？

HashSet是Set接口实现，它按照Hash算法来存储集合中的元素，不保证元素顺序
HashSet是非同步的，如果多个线程同时访问一个HashSet，要通过代码来保证其同步，集合元素可以是null
对于HashSet而言，它是基于HashMap实现的。HashSet底层采用HashMap来保存所有元素

25.ArrayList 和 LinkedList 的区别是什么？

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

ArrayList内部是使用可増长数组实现的，所以是用get和set方法是花费常数时间的，但是如果插入元素和删除元素，除非插入和删除的位置都在表末尾，否则代码开销会很大，因为里面需要数组的移动。增加或删除后需要改变后面所有数组的位置。
LinkedList是使用双链表实现的，所以get会非常消耗资源，除非位置离头部很近。但是插入和删除元素花费常数时间。增加或删除改变指针指向。

1.对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对 ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是 统一的，分配一个内部Entry对象。
2.在ArrayList集合中添加或者删除一个元素时，当前的列表所所有的元素都会被移动。而LinkedList集合中添加或者删除一个元素的开销是固定的。
3.LinkedList集合不支持 高效的随机随机访问（RandomAccess），因为可能产生二次项的行为。
4.ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

26.如何实现数组和 List 之间的转换？

https://blog.csdn.net/zjx2016/article/details/78273192

27.ArrayList 和 Vector 的区别是什么？

Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。
当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

28.Array 和 ArrayList 有何区别？

1、存储内容比较：
Array 数组可以包含基本类型和对象类型，
ArrayList却只能包含对象类型。
Array 数组在存放的时候一定是同种类型的元素。ArrayList 就不一定了 。

2、空间大小比较：
Array 数组的空间大小是固定的,所以需要事前确定合适的空间大小。
ArrayList的空间是动态增长的,而且，每次添加新的元素的时候都会检查内部数组的空间是否足够。

3.方法上的比较：
ArrayList方法上比 Array更多样化，比如添加全部 addAll()、删除全部 removeAll()、返回迭代器 iterator() 等。

适用场景：
如果想要保存一些在整个程序运行期间都会存在而且不变的数据，我们可以将它们放进一个全局数组里， 但是如果我们单纯只是想要以数组的形式保存数据，而不对数据进行增加等操作，只是方便我们进行查找的话，那么，我们就选择 ArrayList。
如果我们需要对元素进行频繁的移动或删除，或者是处理的是超大量的数据，那么，使用 ArrayList 就真的不是一个好的选择，因为它的效率很低，使用数组进行这样的动作就很麻烦，那么，我们可以考虑选择 LinkedList。

29.在 Queue 中 poll()和 remove()有什么区别？

poll()和remove()方法都是从队列中取出一个元素
poll()在获取失败的时候会返回空null
remove()方法在获取数据失败的时候抛出异常

add()和offer()都是向队列中添加一个元素。一些队列有大小限制，因此如果想在一个满的队列中加入一个新项
调用 add()方法就会抛出一个 unchecked 异常，
调用 offer()方法会返回 false。

element() 和 peek()用于在队列的头部查询元素。与 remove() 方法类似
在队列为空时，element()抛出一个异常，而 peek()返回 null。

30.哪些集合类是线程安全的？

Vector：就比Arraylist多了个同步化机制（线程安全）。

Hashtable：就比Hashmap多了个线程安全。

ConcurrentHashMap:是一种高效但是线程安全的集合。

Stack：栈，也是线程安全的，继承于Vector。

enumeration：枚举，相当于迭代器

31.迭代器 Iterator 是什么？

• Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。
• Iterator接口提供很多对集合元素进行迭代的方法，每一个集合类都包含了可以返回迭代器实例的迭代方法。
• 迭代器可以在迭代的过程中删除底层集合的元素，但是不可以删除直接调用集合的remove(Object obj)删除，可以通过迭代器的remove()方法删除

32.Iterator 怎么使用？有什么特点？

//第一种
Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            String string = iterator.next();
            //do something
        }

//第二种
for(Iterator it = c.iterator(); it.hasNext(); ) {
　　Object o = it.next();
　　 //do something

33.Iterator 和 ListIterator 有什么区别？

• Iterator用来遍历Set 和 List集合
• Iterator只可以向前遍历
• ListIterator 只能遍历List
• ListIterator可以双向遍历
• ListIterator 从 Iterator 接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置

34.怎么确保一个集合不能被修改？

可以使用 Collections. unmodifiableCollection(Collection c) 方法来创建一个只读集合，这样改变集合的任何操作都会抛出 Java. lang. UnsupportedOperationException 异常。

List<String> list = new ArrayList<>();
list. add("A");
Collection<String> unmlist = Collections. unmodifiableCollection(list);
unmlist. add("B"); // 运行时此行报错
System. out. println(list.size());

多线程相关

35.并行和并发有什么区别？

• 并发的关键是你有处理多个任务的能力，不一定要同时。
• 并行的关键是你有同时处理多个任务的能力。
  所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。
• 单CPU中进程只能是并发，多CPU计算机中进程可以并行。
• 单CPU单核中线程只能并发，单CPU多核中线程可以并行。
  无论是并发还是并行，使用者来看，看到的是多进程，多线程。

36.线程和进程的区别？

• 进程是执行中的一个应用程序，是程序的一种动态形式，是CPU、内存等资源占用的基本单位，而且进程之间相互独立，通信比较困难，进程在执行的过程中，包含比较固定的入口、执行顺序、出口等
• 进程表示资源分配的基本概念，又是调度原型的基本单位，是系统中并发执行的单位。
• 线程是进程内部的一个执行序列，属于某个进程，线程是进程中执行运算的最小单位。一个进程可以有多个线程，线程不能占用CPU、内存等资源。而且线程之间共享一块内存区域，通信比较方便，线程的入口执行顺序这些过程被应用程序所控制。

37.守护线程是什么？

• 守护线程是程序运行的时候在后台提供一种通用服务的线程。所有用户线程停止，进程会停掉所有守护线程，退出程序。
• Java中把线程设置为守护线程的方法：在start 线程之前调用线程的 setDaemon(true)方法。

38.线程有哪些状态？

• 新建状态: 一个新产生的线程从新状态开始了它的生命周期。它保持这个状态直到程序 start 这个线程。
• 就绪状态:当一个线程等待另外一个线程执行一个任务的时候，该线程就进入就绪状态。当另一个线程给就绪状态的线程发送信号时，该线程才重新切换到运行状态。
• 运行状态:当一个新状态的线程被 start 以后，线程就变成可运行状态，一个线程在此状态下被认为是开始执行其任务
• 休眠状态: 由于一个线程的时间片用完了，该线程从运行状态进入休眠状态。当时间间隔到期或者等待的时间发生了，该状态的线程切换到运行状态。
• 终止状态: 一个运行状态的线程完成任务或者其他终止条件发生，该线程就切换到终止状态。

39.sleep() 和 wait() 有什么区别？

• sleep()是线程类（Thread)的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
• wait()是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

40.notify()和 notifyAll()有什么区别？

前提条件：wait()方法表示，放弃当前对资源的占有权时

• notify()方法表示，当前的线程已经放弃对资源的占有，
  通知等待的线程来获得对资源的占有权，但是只有一个线程能够从wait状态中恢复，
  然后继续运行wait()后面的语句；
• notifyAll()使所有原来在该对象上等待被notify的所有线程统统退出wait的状态，变成等待该对象上的锁，一旦该对象被解锁，他们就会去竞争。

41.线程的 run()和 start()有什么区别？

• run() :方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的
• start() :它的作用是启动一个新线程，新线程会执行相应的run()方法。start()不能被重复调用,真正的实现了多线程并发运行。

42.创建线程有哪几种方式？(非常重要，自己回顾一下）

• 继承Thread类
• 实现Runnable接口
• 实现Callable接口
• 应用程序可以使用Executor来创建线程池
• 实现Runnable接口这种方式最受欢迎，因为不需要继承Thread类，无法多继承，可以多实现，干很多其他事。同时线程池是非常高效的，很容易实现和使用。

43.常用的线程池

四种，看多线程那章文章详解

44.线程池都有哪些状态？

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。

45.线程池的实现原理

• 线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作
  线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下个流程。

• 线程池判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这
  个工作队列里。如果工作队列满了，则进入下个流程。

• 线程池判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程
  来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

46.线程池的几种实现方式

四种

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规则可以解决有序性问题

Happens-Before 规则如下：

程序次序规则：在一个线程内，按照程序控制流顺序，书写在前面的操作先行发生于书写在后面的操作
管程锁定规则：一个unlock操作先行发生于后面对同一个锁的lock操作
volatile变量规则：对一个volatile变量的写操作先行发生于后面对这个变量的读操作
线程启动规则：Thread对象的start()方法先行发生于此线程的每一个动作
线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测
线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
对象终结规则：一个对象的初始化完成(构造函数执行结束)先行发生于它的finalize()方法的开始

48.多线程锁的升级原理是什么？

锁的级别从低到高：

无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁

锁分级别原因：

没有优化以前，sychronized是重量级锁（悲观锁），使用 wait 和 notify、notifyAll 来切换线程状态非常消耗系统资源；线程的挂起和唤醒间隔很短暂，这样很浪费资源，影响性能。所以 JVM 对 sychronized 关键字进行了优化，把锁分为 无锁、偏向锁、轻量级锁、重量级锁 状态。

• 无锁：没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功，其他修改失败的线程会不断重试直到修改成功。

• 偏向锁：对象的代码一直被同一线程执行，不存在多个线程竞争，该线程在后续的执行中自动获取锁，降低获取锁带来的性能开销。偏向锁，指的就是偏向第一个加锁线程，该线程是不会主动释放偏向锁的，只有当其他线程尝试竞争偏向锁才会被释放。

  • 偏向锁的撤销，需要在某个时间点上没有字节码正在执行时，先暂停拥有偏向锁的线程，然后判断锁对象是否处于被锁定状态。如果线程不处于活动状态，则将对象头设置成无锁状态，并撤销偏向锁；
  • 如果线程处于活动状态，升级为轻量级锁的状态。

• 轻量级锁：轻量级锁是指当锁是偏向锁的时候，被第二个线程 B 所访问，此时偏向锁就会升级为轻量级锁，线程 B 会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。
  当前只有一个等待线程，则该线程将通过自旋进行等待。但是当自旋超过一定的次数时，轻量级锁便会升级为重量级锁；当一个线程已持有锁，另一个线程在自旋，而此时又有第三个线程来访时，轻量级锁也会升级为重量级锁。

• 重量级锁：指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。
  重量级锁通过对象内部的监视器（monitor）实现，而其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现，操作系统实现线程之间的切换需要从用户态切换到内核态，切换成本非常高。
  
  

49.什么是死锁？

• 死锁的定义是：在一个进程组内，每个进程都在等待只有其他进程才能引发的事件，那么该进程组处于死锁状态。
• 有两个线程（或者更多的线程），每个线程都在等待被其他线程占用的资源。
• 比如：线程A有1号资源，它还想要2号资源；线程B有2号资源，它还想要1好资源；从而两个线程在互相等待对方的资源，都不给对方让资源，却又都得不到，就会导致这两个线程处于死锁状态。

死锁产生的原因：

（1）竞争资源；系统资源有限，不能满足每一个进程的要求；
（2）多道程序运行时，推进进程运行的顺序不合理。

死锁的四个必要条件

（1）请求和保持：每个进程都在请求还未得到的资源，但是又一直拿着自己已有的资源不放；
（2）互斥条件：每个资源只能被一个进程所使用；
（3）不可剥夺：对于其他进程已经获得的资源，在它为释放该资源之前，这个资源不能被其他进程剥夺；
（4）循环等待：进程组内进程之间形成循环等待资源的情形。

死锁的预防

• 我们知道了死锁产生的四个必要条件，必要条件是指只要我们打破这四个条件中的一个，那么就可以预防死锁
• 死锁预防是指使系统不进入死锁状态的一种策略，通过遵循一种策略来打破这四个必要条件中的一个或者几个。
  （1）打破互斥条件：允许一个资源可以被几个进程同时访问，但是对于一般的资源来说这是不可行的；
  （2）打破请求和保持条件：提前对所有资源进行分配，看这样的分配策略是否恰当。但是在很多时候，资源的多少是动态的，计算起来并不容易。
  （3）打破不可剥夺条件：允许进程剥夺其他进程拥有的资源，就是说，当一个进程在申请某个资源却得不到的时候，它必须释放自己所的资源，这样这个进程的资源就可以被别的进程所用；
  （4）打破循环等待条件：对资源提前编号处理，是资源在使用时计算是否会形成环路。

50.怎么防止死锁？

51.ThreadLocal 是什么？有哪些使用场景？

线程局部变量是局限于线程内部的变量，属于线程自身所有，不在多个线程间共享。Java提供ThreadLocal类来支持线程局部变量，是一种实现线程安全的方式。但是在管理环境下（如 web 服务器）使用线程局部变量的时候要特别小心，在这种情况下，工作线程的生命周期比任何应用变量的生命周期都要长。任何线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险。

52.说一下 synchronized 底层实现原理？

• synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。
• Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
• 普通同步方法，锁是当前实例对象
• 静态同步方法，锁是当前类的class对象
• 同步方法块，锁是括号里面的对象

53.synchronized 和 volatile 的区别是什么？

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

54.synchronized 和 Lock 有什么区别？

• 首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
• synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
• synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
• 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
• synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）；
• Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

55.synchronized 和 ReentrantLock 区别是什么？

synchronized是和if、else、for、while一样的关键字，ReentrantLock是类，这是二者的本质区别。既然ReentrantLock是类，那么它就提供了比synchronized更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量，ReentrantLock比synchronized的扩展性体现在几点上：
ReentrantLock可以对获取锁的等待时间进行设置，这样就避免了死锁
ReentrantLock可以获取各种锁的信息
ReentrantLock可以灵活地实现多路通知
另外，二者的锁机制其实也是不一样的:ReentrantLock底层调用的是Unsafe的park方法加锁，synchronized操作的应该是对象头中mark word。

56.说一下 atomic 的原理？

Atomic包中的类基本的特性就是在多线程环境下，当有多个线程同时对单个（包括基本类型及引用类型）变量进行操作时，具有排他性，即当多个线程同时对该变量的值进行更新时，仅有一个线程能成功，而未成功的线程可以向自旋锁一样，继续尝试，一直等到执行成功。

Atomic系列的类中的核心方法都会调用unsafe类中的几个本地方法。我们需要先知道一个东西就是Unsafe类，全名为：sun.misc.Unsafe，这个类包含了大量的对C代码的操作，包括很多直接内存分配以及原子操作的调用，而它之所以标记为非安全的，是告诉你这个里面大量的方法调用都会存在安全隐患，需要小心使用，否则会导致严重的后果，例如在通过unsafe分配内存的时候，如果自己指定某些区域可能会导致一些类似C++一样的指针越界到其他进程的问题。

反射相关

57.什么是反射？

反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力

Java反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。

58.什么是 java 序列化？什么情况下需要序列化？

简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。

• 什么情况下需要序列化：
  a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
  b）当你想用套接字在网络上传送对象的时候；
  c）当你想通过RMI传输对象的时候；

59.动态代理是什么？有哪些应用？

当想要给实现了某个接口的类中的方法，加一些额外的处理。比如说加日志，加事务等。可以给这个类创建一个代理，故名思议就是创建一个新的类，这个类不仅包含原来类方法的功能，而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的，是动态生成的。具有解耦意义，灵活，扩展性强。

• 动态代理的应用：
  Spring的AOP、加事务、加权限、加日志

60.怎么实现动态代理？

首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回。

61.为什么要使用克隆？

想对一个对象进行处理，又想保留原有的数据进行接下来的操作，就需要克隆了，Java语言中克隆针对的是类的实例

62.如何实现对象克隆？

两种方式：

• 实现Cloneable接口并重写Object类中的clone()方法；
• 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆

63.深拷贝和浅拷贝区别是什么？

• 浅拷贝只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化，这就是浅拷贝（例：assign()）
• 深拷贝是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变，这就是深拷贝（例：JSON.parse()和JSON.stringify()，但是此方法无法复制函数类型）

64 char 和 varchar 的区别是什么？

• char的长度是固定的，而varchar的长度是可以变化的
• char的效率比varchar的效率稍高,varchar2比char更节省存储空间
• char插入空值是会占用存储空间的，而varchar和varchar2不会占用空间。varchar存储空，而varchar用null表示存储空。

65 float 和 double 的区别是什么？

• float:单精度类型,精度是8位有效数字，取值范围是10的-38次方到10的38次方，float占用4个字节的存储空间
• double:双精度类型，精度是17位有效数字，取值范围是10的-308次方到10的308次方，double占用8个字节的存储空间
• 若不声明的，默认小数都用double来表示，所以如果要用float的话，则应该在其后加上f
  • 例如：float a=1.63;//会显示错误，正确的写法为float a=1.63f;则会提示不能将double转化成float 这成为窄型转化
  • 注意float是8位有效数字，第7位数字将会产生四舍五入
    所以如果一个float变量 这样定义: float a=1.32344435; 则第7位将产生四舍五入(5及5以下的都将舍去)
• 一般开发中建议用double 修饰小数

66 final, finally 和 finalize 的区别

• final用于声明属性，方法和类，表示属性不可变，方法不可被重写，类不可被继承。
• finally 是异常处理语句结构的一部分，表示总是执行。
• finalize是 object 类的一个方法，在垃圾收集器执行的时候会调用这个对象回收的方法，工垃圾收集时其他资源的回收，比如关闭文件。

67 为什么Java被称作是平台无关性

• Java虚拟机是执行字节码文件(.class)的虚拟机进程。Java源程序(.java)被编译器编译成字节码文件(.class)。然后字节码文件将由Java虚拟机解释成机器码（不同平台的机器码不同）；有利于机器码操作硬件和操作系统
• 因为在不同的平台上都安装不同的JVM虚拟机，他们能够将相同的字节码(.class）文件解释成不同平台需要的机器码。正是由于JVM的存在，Java语言才被称作为平台无关的编程语言。

68 构造器Constructor是否可被override?

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

69 java类什么时候被初始化？

• 只有这6中情况才会导致类的类的初始化。
  1）创建类的实例，也就是new一个对象
  2）访问某个类或接口的静态变量，或者对该静态变量赋值
  3）调用类的静态方法
  4）反射（Class.forName(“haha”)）
  5）初始化一个类的子类（会首先初始化子类的父类）
  6）JVM启动时标明的启动类，即文件名和类名相同的那个类

70 字节流如何转为字符流

• 字节输入流转字符输入流通过InputStreamReader实现，该类的构造函数可以传入InputStream对象。
• 字节输出流转字符输出流通过OutputStreamWriter实现，该类的构造函数可以传入OutputStream对象。

异常相关

71.什么是异常

• 异常是指程序在运行过程中发生的一些不正常事件

72.Java中的异常处理关键字是什么？

• throw：有时我们明确要创建异常对象然后抛出它来停止程序的正常处理。throw关键字用于向运行时抛出异常来处理它。
• throws：当我们在方法中抛出任何已检查的异常而不处理它时，我们需要在方法签名中使用throws关键字让调用者程序知道该方法可能抛出的异常。调用方法可以处理这些异常或使用throws关键字将其传播给它的调用方法。我们可以在throws子句中提供多个异常，也可以与main（）方法一起使用。
• try-catch：我们在代码中使用try-catch块进行异常处理。try是块的开始，catch是在try块的末尾处理异常。我们可以使用try有多个catch块，try-catch块也可以嵌套。catch块需要一个应该是Exception类型的参数。
• finally：finally块是可选的，只能用于try-catch块。由于异常会暂停执行过程，因此我们可能会打开一些不会关闭的资源，因此我们可以使用finally块。finally块总是被执行，无论是否发生异常。

73.Error和Exception有什么区别

• Error表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

• Error:是JVM发生问题…程序员是无法修复的…

• Exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

• Exception:是异常可以修复的代码…

74.throw 和 throws 的区别？

• throw关键字用来在程序中明确抛出的异常， throws语句用来表名方法不能处理的异常
• throw用于方法内部，throws用于方法声明上
• throw后跟异常对象，throws后跟异常类型
• throw后只能跟一个异常对象，throws后可以一次声明多种异常类型

75.final、finally、finalize 有什么区别？

• final关键字，修饰变量，方法，类等
• finally：用于异常处理，无论是否抛出异常，如果在之前没有将System.exit()就可以，finally代码块都会执行，它主要是用来释放应用占用的资源。
• finalize()方法是Object类的一个protected方法，它在对象被垃圾处理器回收前由Java虚拟机来调用。

76.try-catch-finally 中哪个部分可以省略？

二者省略其一

public class TestOmitTryCatchFinally {

public static void main(String[] args) {
	omitFinally();
	omitCatch();
}

/**
 * 省略finally 语句块
 */
public static void omitFinally() {
	try {
		int i = 0;
		i += 1;
		System.out.println(i);
	} catch (Exception e) {
		e.printStackTrace();
	}
}

/**
 * 省略 catch 语句块
 */
public static void omitCatch() {
	int i = 0;
	try {
		i += 1;
	} finally {
		i = 10;
	}
	System.out.println(i);
}
}

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

• 查看博客https://blog.csdn.net/qq_40180411/article/details/81428382
• finally任何时候都会执行的

78.常见的异常类有哪些？

Throwable
├ Error  

│ ├ IOError
│ ├ LinkageError
│ ├ ReflectionError
│ ├ ThreadDeath
│ |- VirtualMachineError

├ Exception  
│ ├ CloneNotSupportedException
│ ├ DataFormatException
│ ├ InterruptedException
│ ├ IOException
│ ├ ReflectiveOperationException
│ ├ RuntimeException  运行期异常
│    ├ ArithmeticException
│    ├ ClassCastException
│    ├ ConcurrentModificationException
│    ├ IllegalArgumentException
│    ├ IndexOutOfBoundsException
│    ├ NoSuchElementException
│    ├ NullPointerException
│　|- SecurityException
│ |- SQLException

网络协议

79.http 响应码 301 和 302 代表的是什么？有什么区别？

301，302 都是HTTP状态的编码，都代表着某个URL发生了转移。

• 区别：
  301 redirect: 301 代表永久性转移(Permanently Moved)。
  302 redirect: 302 代表暂时性转移(Temporarily Moved )。

80.forward 和 redirect 的区别？

Forward和Redirect代表了两种请求转发方式：直接转发和间接转发。

• 直接转发方式（Forward），客户端和浏览器只发出一次请求，Servlet、HTML、JSP或其它信息资源，由第二个信息资源响应该请求，在请求对象request中，保存的对象对于每个信息资源是共享的。
• 间接转发方式（Redirect）实际是两次HTTP请求，服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的。

81.简述 tcp 和 udp的区别？

• TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接。
• TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付。
• TCP通过校验和，重传控制，序号标识，滑动窗口、确认应答实现可靠传输。如丢包时的重发控制，还可以对次序乱掉的分包进行顺序控制。
• UDP具有较好的实时性，工作效率比TCP高，适用于对高速传输和实时性有较高的通信或广播通信。
• 每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信。
• TCP对系统资源要求较多，UDP对系统资源要求较少。

82.tcp 为什么要三次握手，两次不行吗？为什么？

为了实现可靠数据传输， TCP 协议的通信双方， 都必须维护一个序列号， 以标识发送出去的数据包中， 哪些是已经被对方收到的。 三次握手的过程即是通信双方相互告知序列号起始值， 并确认对方已经收到了序列号起始值的必经步骤。
如果只是两次握手， 至多只有连接发起方的起始序列号能被确认， 另一方选择的序列号则得不到确认。

83.说一下 tcp 粘包是怎么产生的？

84.OSI 的七层模型都有哪些？

应用层：网络服务与最终用户的一个接口。
表示层：数据的表示、安全、压缩。
会话层：建立、管理、终止会话。
传输层：定义传输数据的协议端口号，以及流控和差错校验。
网络层：进行逻辑地址寻址，实现不同网络之间的路径选择。
数据链路层：建立逻辑连接、进行硬件地址寻址、差错校验等功能。
物理层：建立、维护、断开物理连接。

85.get 和 post 请求有哪些区别？

LET在浏览器回退时是无害的，而POST会再次提交请求。
GET产生的URL地址可以被Bookmark，而POST不可以。
GET请求会被浏览器主动cache，而POST不会，除非手动设置。
GET请求只能进行url编码，而POST支持多种编码方式。
GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。
GET请求在URL中传送的参数是有长度限制的，而POST么有。
参数的数据类型，GET只接受ASCII字符，而POST没有限制。
ET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。
GET参数通过URL传递，POST放在Request body中。

86.如何实现跨域？

这个比较复杂，百度吧

87.说一下 JSONP 实现原理？

jsonp 即 json+padding，动态创建script标签，利用script标签的src属性可以获取任何域下的js脚本，通过这个特性(也可以说漏洞)，服务器端不在返货json格式，而是返回一段调用某个函数的js代码，在src中进行了调用，这样实现了跨域。

设计模式

88.说一下你熟悉的设计模式？

89.简单工厂和抽象工厂有什么区别？

90 手写单例设计模式

JVM

93 什么是 GC？为什么要有 GC？

• GC（Garbage Collection）是垃圾收集的意思，负责清除对象并释放内存。
• Java 提供的 GC 功能可以自动检测对象是否超过作用域从而达到自动回收内存的目的，从而防止内存泄漏。

94.说一下 jvm 的主要组成部分？及其作用？

• 类加载器（ClassLoader）
• 运行时数据区（Runtime Data Area）
• 执行引擎（Execution Engine）
• 本地库接口（Native Interface）
• 组件的作用： 首先通过类加载器（ClassLoader）会把 Java 代码转换成字节码，运行时数据区（Runtime Data Area）再把字节码加载到内存中，而字节码文件只是 JVM 的一套指令集规范，并不能直接交个底层操作系统去执行，因此需要特定的命令解析器执行引擎（Execution Engine），将字节码翻译成底层系统指令，再交由 CPU 去执行，而这个过程中需要调用其他语言的本地库接口（Native Interface）来实现整个程序的功能。

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

程序计数器、虚拟机栈、本地方法栈、堆、方法区

• 有的区域随着虚拟机进程的启动而存在，有的区域则依赖用户进程的启动和结束而创建和销毁。

96.说一下堆栈的区别？

• 栈内存存储的是局部变量而堆内存存储的是实体；
• 栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短
• 栈内存存放的变量生命周期一旦结束就会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收

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

队列和栈都是被用来预存储数据的。
队列允许先进先出检索元素，但也有例外的情况，Deque 接口允许从两端检索元素。
栈和队列很相似，但它运行对元素进行后进先出进行检索。

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

在介绍双亲委派模型之前先说下类加载器。对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立在 JVM 中的唯一性，每一个类加载器，都有一个独立的类名称空间。类加载器就是根据指定全限定名称将 class 文件加载到 JVM 内存，然后再转化为 class 对象。

类加载器分类：

• 启动类加载器（Bootstrap ClassLoader），是虚拟机自身的一部分，用来加载Java_HOME/lib/目录中的，或者被 -Xbootclasspath 参数所指定的路径中并且被虚拟机识别的类库；
  其他类加载器：
  扩展类加载器（Extension ClassLoader）：负责加载\lib\ext目录或Java. ext. dirs系统变量指定的路径中的所有类库；
• 应用程序类加载器（Application ClassLoader）。负责加载用户类路径（classpath）上的指定类库，我们可以直接使用这个类加载器。一般情况，如果我们没有自定义类加载器默认就是用这个加载器。
• 双亲委派模型：如果一个类加载器收到了类加载的请求，它首先不会自己去加载这个类，而是把这个请求委派给父类加载器去完成，每一层的类加载器都是如此，这样所有的加载请求都会被传送到顶层的启动类加载器中，只有当父加载无法完成加载请求（它的搜索范围中没找到所需的类）时，子加载器才会尝试去加载类。

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

• 类加载分为以下 5 个步骤：
  加载：根据查找路径找到相应的 class 文件然后导入；
  检查：检查加载的 class 文件的正确性；
  准备：给类中的静态变量分配内存空间；
  解析：虚拟机将常量池中的符号引用替换成直接引用的过程。符号引用就理解为一个标示，而在直接引用直接指向内存中的地址；
  初始化：对静态变量和静态代码块执行初始化工作。

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

一般有两种方法来判断：

• 引用计数器：为每个对象创建一个引用计数，有对象引用时计数器 +1，引用被释放时计数 -1，当计数器为 0 时就可以被回收。它有一个缺点不能解决循环引用的问题；
• 可达性分析：从 GC Roots 开始向下搜索，搜索所走过的路径称为引用链。当一个对象到 GC Roots 没有任何引用链相连时，则证明此对象是可以被回收的

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

强引用、软引用、弱引用、虚引用（幽灵引用/幻影引用）

• 强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象
• 软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。
• 弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象
• 虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

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

标记-清除算法
标记-整理算法
复制算法
分代算法

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

• Serial：最早的单线程串行垃圾回收器。
• Serial Old：Serial 垃圾回收器的老年版本，同样也是单线程的，可以作为 CMS 垃圾回收器的备选预案。
• ParNew：是 Serial 的多线程版本。
• Parallel 和 ParNew 收集器类似是多线程的，但 Parallel 是吞吐量优先的收集器，可以牺牲等待时间换取系统的吞吐量。
• Parallel Old 是 Parallel 老生代版本，Parallel 使用的是复制的内存回收算法，Parallel Old 使用的是标记-整理的内存回收算法。
• CMS：一种以获得最短停顿时间为目标的收集器，非常适用 B/S 系统。
• G1：一种兼顾吞吐量和停顿时间的 GC 实现，是 JDK 9 以后的默认 GC 选项。

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

CMS 是英文 Concurrent Mark-Sweep 的简称，是以牺牲吞吐量为代价来获得最短回收停顿时间的垃圾回收器。对于要求服务器响应速度的应用上，这种垃圾回收器非常适合。在启动 JVM 的参数加上“-XX:+UseConcMarkSweepGC”来指定使用 CMS 垃圾回收器。

CMS 使用的是标记-清除的算法实现的，所以在 gc 的时候回产生大量的内存碎片，当剩余内存不能满足程序运行要求时，系统将会出现 Concurrent Mode Failure，临时 CMS 会采用 Serial Old 回收器进行垃圾清除，此时的性能将会被降低。

105.新生代垃圾回收器和老生代垃圾回收器都有哪些？有什么区别？

• 新生代回收器：Serial、ParNew、Parallel Scavenge
• 老年代回收器：Serial Old、Parallel Old、CMS
• 整堆回收器：G1

新生代垃圾回收器一般采用的是复制算法，复制算法的优点是效率高，缺点是内存利用率低；老年代回收器一般采用的是标记-整理的算法进行垃圾回收。

106.简述分代垃圾回收器是怎么工作的？

• 分代回收器有两个分区：老生代和新生代，新生代默认的空间占比总空间的 1/3，老生代的默认占比是 2/3。

• 新生代使用的是复制算法，新生代里有 3 个分区：Eden、To Survivor、From Survivor，它们的默认占比是 8:1:1，它的执行流程如下：
  把 Eden + From Survivor 存活的对象放入 To Survivor 区；清空 Eden 和 From Survivor 分区；From Survivor 和 To Survivor 分区交换，From Survivor 变 To Survivor，To Survivor 变 From Survivor。

• 每次在 From Survivor 到 To Survivor 移动时都存活的对象，年龄就 +1，当年龄到达 15（默认配置是 15）时，升级为老生代。大对象也会直接进入老生代。

• 老生代当空间占用到达某个值之后就会触发全局垃圾收回，一般使用标记整理的执行算法。以上这些循环往复就构成了整个分代垃圾回收的整体执行流程。

107.说一下 jvm 调优的工具？

JDK 自带了很多监控工具，都位于 JDK 的 bin 目录下，其中最常用的是 jconsole 和 jvisualvm 这两款视图监控工具。

• jconsole：用于对 JVM 中的内存、线程和类等进行监控；
• jvisualvm：JDK 自带的全能分析工具，可以分析：内存快照、线程快照、程序死锁、监控内存的变化、gc 变化等。

108.常用的 jvm 调优的参数都有哪些？

1、-Xms s为strating，表示堆内存起始大小

2、-Xmx：x为max，表示最大的堆内存（一般来说-Xms和-Xmx的设置为相同大小，因为当heap自动扩容时，会发生内存抖动，影响程序的稳定性）

3、-Xmn： n为new，表示新生代大小（-Xss：规定了每个线程虚拟机栈（堆栈）的大小）

4、-XX:SurvivorRator=8： 表示堆内存中新生代、老年代和永久代的比为8:1:1

5、-XX:PretenureSizeThreshold=3145728 表示当创建（new）的对象大于3M的时候直接进入老年代

6、-XX:MaxTenuringThreshold=15 表示当对象的存活的年龄（minor gc一次加1）大于多少时，进入老年代

7、-XX:-DisableExplicirGC 表示是否（+表示是，-表示否）打开GC日志

109 Java中什么时候进行回收，垃圾回收有什么目的

• 垃圾回收是内存中存在没有引用的对象或超过作用域的对象时进行。
• 垃圾回收的目的是识别并且丢弃应用中不再使用的对象来释放和重用资源。

109 abstract方法不能够和static连用，为什么？

• static修饰的为静态方法，而abstract修饰的为抽象方法，无方法体的方法，无法调用
• abstract方法需要子类重写，而静态方法不能被重写，二者相互矛盾

110.String s = “a” + “b” +“c” + "d"创建了几个对象？

一个对象

public class Test9 {
	public static void main(String[] args) {
		String s1 = "a";
		String s2 = s1 + "b";
		String s3 = "a" + "b";
		System.out.println(s2 == "ab"); // false
		System.out.println(s3 == "ab"); // true
	}
}

111.hashCode和equals的关系

• hash是散列的意思，即把任意长度的输入，通过散列算法转换成固定长度的输出，该输出就是散列值
  • 1.不同关键字经过散列算法变换后可能会得到同一个散列地址，这种的称为Hash碰撞
  • 2.如果两个Hash值不同，（前提是同一个Hash算法）那么这两个Hash值对应的原始输入必定不同
• HashCode()的作用：为了获取哈希散列码，返回int型整数
  • 1.HashCode的存在主要是为了提高在散列结构中查找的效率，在线性表中没有作用
    在HashMap中put里调用了hashCode算法，那么get肯定也有，int比对肯定比String比对要快。即先用hash懂得确定一个范围。
  • 2.两个相等对象分别调用equals时都会返回true
  • 3.如果两个对象equals() return true,则HashCode一定相同
  • 4.两个对象Hash Code相同，不代表两个对象相同，只能说明这两个对象在散列存储结构中处于相同的位置
  • 5.因此equals方法被覆盖，则HashCode方法也必须被覆盖
  • 6.hashCode的默认行为是在堆中的对象产生独特值
  • 7.Integer的HashCode是它自身

115.Java类的初始化顺序

• 类的大致加载顺序：
  静态块，普通方法块，构造方法，成员变量
• 实际顺序:
  父类的静态代码块 || 父类的静态成员 —>子类的静态代码块 || 子类的静态成员 —>
  父类普通代码块 || 父类的普通成员 —> 父类的构造方法 —>子类的普通代码块 || 子类的普通成员—> 子类的构造方法

116.switch中能否使用string做参数?

在JDK 1.7之前,switch只能支持byte,short,char,int或者其对应的包装类以及Enum类型.从JDK 1.7之后switch开始支持String类型.但到目前为止,switch都不支持long类型.

117.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

• 对于short s1 = 1; s1 = s1 + 1; 由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。
• 对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。