Java的一些常见八股文

最新推荐文章于 2024-07-03 13:40:40 发布

快叫我去刷LeetCode

最新推荐文章于 2024-07-03 13:40:40 发布

阅读量2.7k

点赞数

文章标签： java 开发语言后端

原文链接：https://blog.csdn.net/qq_34337272/article/details/105338143?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163629014116780261927648%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=163629014116780261927648&biz_i

版权

本文基本都是阅读《Javaguide面试突击版》的总结，仅用于个人学习总结，如有侵权立刻删除。

原文链接：Javaguide面试突击版

Java

一、基础

1.==和equals的区别

是java中的比较运算符，它比较的是两者的内存地址（即判断两个对象是不是同一个对象）。基本数据类型比较的是值，而引用数据类型==比较的是内存地址。
equals是object类里面的方法，具体要看object类有没有重写该方法，如integer类和string类里就重写了该方法，重写后比较的就是两者的内容是否相同。

public class TestEquals {
	public static void main(String[] args) {
		String a=new String("abc");
		String b=new String("abc");
		//false 因为==比较的是内存地址，a、b为不同的对象
		System.out.println(a==b);
        //true string类里的equals方法被重写了，这里比较的是两者的内容
		System.out.println(a.equals(b));
		
		String str1="你好";
		String str2="你好";
		//true 没有新创建对象
		System.out.println(str1==str2);
        //true 二者内容一样
		System.out.println(str1.equals(str2));	
	}
}

2.Java 和C++的区别

都是面向对象编程，都支持继承封装多态
Java不提供指针来直接访问内存，程序内存更加安全
Java有自己的内存管理机制，不需要自己手动释放无用内存
Java是单继承，而C++支持多重继承，不过Java可以通过接口实现多重继承
在C语言中，字符串或者字符串数组的结尾都有一个‘\0’来表示结束，Java中没有这样的概念。

3.重载和重写的区别

总的来说：

重载：同一个方法名有不同的参数类型、参数数量、参数顺序做出不同的逻辑处理，发生在编译期。

重写：当子类继承父类相同方法时，输入数据一样，但要做出与父类方法不同的反应时，要覆盖父类的方法，发生在运行期。

重写当遵循“两同两小一大”：

“两同”指方法名相同，参数相同
“两小”指子类返回值类型要比父类更小或相等，子类抛出的异常类应比父类更小或相等，“一大”指子类的访问权限应当比父类的要更大或相等。

4.String StringBuffer和StringBuilder的区别是什么？String为什么是不可变的？

String类中使用final关键字来修饰字符数组来保存字符串，所以String对象是不可变的。
StringBuilder与StringBuffer都继承自AbstractStringBuilder类，该类中也是使用字符数组来保存字符串，但没有用final来修饰，所以二者对象是可变的。
线程安全性 :

String中的对象是不可变的，也可以理解为常量，线程安全。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以线程是安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
性能：

相同情况下使用StringBuilder仅能比使用StringBuffer提高10%~15%的性能，但却要冒多线程不安全的风险。
总结：

1.操作较少数据的时候用String

2.使用单线程操作字符串缓冲区下大量数据用StringBuilder

3.使用多线程操作字符串缓冲区下大量数据用StringBuffer

5.自动装箱与拆箱

Java中，一切都是对象，但有例外：8个基本数据类型不是。因此Java为它们提供了包装类：

基本数据	包装类
byte	Byte
short	Short
long	Long
boolean	Boolean
int	Integer
char	Character
float	Float
double	Double

装箱：当我们把一个基本类型的值赋值给引用变量的时候，系统可以自动将它们包装成对象

拆箱：当我们需要一个基本类型的值，但实际上传入的是一个对象时会自动拆箱，得到它的值。

下面这串代码会输出什么？

public class Main {
    public static void main(String[] args) {
         
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;   
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}
 
//true
//false

输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。

6.在一个静态方法里调用一个非静态方法为什么是非法的？

由于静态方法可以不通过对象调用，因此在静态方法中不可以调用非静态方法，也不可以访问非静态变量。

7.成员变量和局部变量的区别有哪些？

语法上：成员变量定义在类里，可以被权限修饰符和static修饰；

局部变量定义在方法里，不可以被权限修饰符及static修饰。

（两者都可以被final修饰）
从变量的存储方式来看：成员变量如果被final修饰，是属于类的，没被final修饰是属于实例的。存放在堆空间中，如果局部变量是基本数据类型，存放在栈空间中，如果是引用数据类型存放的是指向堆内存对象的引用或是指向常量池的地址。
从生存时间看，成员变量随着对象的创建而存在，而局部变量随着方法的调用而消失
成功变量没有赋初值的时候会自动以类型的默认值赋初值，而局部变量不会赋初值。

8.构造方法特性

名字与类相同
没有返回值，但不能用void声明
生成类的对象时自动执行，不需调用

9.hashCode与equals

hashCode()介绍：

hashCode（）的作用是获取哈希码，也成为散列码，这个散列码的作用是确定该对象在哈希表中的索引位置。

为什么要有hashCode？

我们用HashSet如何检查重复为例来说明为什么要有hashCode：

当你把对象插入HashSet中的时候，首先会检查HashSet里是否存在跟新插入对象一样的hashCode，如果没有相符的hashCode，HashSet会假设不存在重复。如果匹配到相符的hashCode，此时会调用equals方法来验证hashCode相同的两个对象是否真的相同，相同则不会允许插入。这样就大大减少了equals的使用次数，提高了执行速度
为什么重写equals()方法时必须重写hashCode()?

如果两个对象相同时，它们的hashCode一定相同，这时用equals方法判断时会返回true，可实际上hashCode相同，两个对象也不一定相同。所以当equals被重写后，hashCode一定要重写
为什么两个对象有相同的hashCode值，它们也不一定是相等的？

hashCode所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞，hashCode只是用来缩小查找成本的。

10.Java中为什么只有值传递？

首先回顾下有关程序设计语言中将参数传递给方法的一些专业术语：
- 按值调用：表示方法接收的是调用者的值
- 按引用调用：表示方法接收的是调用者提供的变量地址
Java中总是采用按值调用，也就是说，方法得到的是所有参数值的一个拷贝，即方法不能修改任何参数变量的内容。

e.g.1:

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;

    swap(num1, num2);

    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;

    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

输出结果为：

a = 20
b = 10
num1 = 10
num2 = 20

解析：

example 1

在 swap 方法中，a、b 的值进行交换，并不会影响到 num1、num2。因为，a、b 中的值，只是从 num1、num2 的复制过来的。也就是说，a、b 相当于 num1、num2 的副本，副本的内容无论怎么修改，都不会影响到原件本身。

e.g.2

    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5 };
        System.out.println(arr[0]);
        change(arr);
        System.out.println(arr[0]);
    }

    public static void change(int[] array) {
        // 将数组的第一个元素变为0
        array[0] = 0;
    }

输出结果：

1
0

解析：

array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的是同一个数组对象。因此，外部对引用对象的改变会反映到所对应的对象上。

11.线程、程序、进程的基本概念，以及它们的关系是什么？

程序是指含有指令和数据的文件，换句话说就是静态的代码。
进程是程序的一次执行过程，是系统运行的程序的基本单位。一次程序执行意味着一个进程的创建、运行到消亡的过程。每个进程都占有一定的系统资源，如CPU时间、内存空间，输入输出设备的使用权等等。线程是进程的更小运行单位，它们的区别是，进程是独立的，而线程不是。换句话说，进程是操作系统的范畴，是同一个时间可以运行多个程序，而线程则是在同一时间内几乎执行一个以上的程序段。
线程一个比进程更小的执行单位，一个进程在执行过程中可以产生多个线程。与进程不同的是，多个线程共享一块内存空间和一组系统资源，所以系统在产生一个线程，或是在多个线程中切换工作的时候，负担要比进程小得多，因此线程也称为轻量级进程。开销小，但不利于资源的管理和保护。

什么是线程池？

12.线程有哪些状态？

状态名称	说明
NEW	创建状态，指线程被创建但还没调用start（）方法。
RUNABLE	运行状态，Java将操作系统的就绪和运行笼统称为运行中。
BLOCKED	阻塞状态，表示线程阻塞于锁。
WAITING	等待状态，表示当前线程等待其他的线程的特定动作（通知或中断）。
TIME_WAITING	超时等待状态，与WAITING不同，它是可以在指定时间内自行返回
TERMINATED	终止状态，表示该线程执行完毕。

13.Java中的异常处理

Java异常类层次结构图

Java中所有的异常都有一个共同的祖先，Throwable类。该类其下有两个类：Exception类（能被程序处理的）、Error（不能处理，只能提前避免）类。Exception类下又有Check Exceptions类（受检查异常类）和Uncheck Exception类（不受检查异常类）。
- Error：StackOverFlowError(栈溢出错误，如无限递归导致堆栈空间满)、VirtualMachineError(Java虚拟机运行错误)、OutOfMemoryError(虚拟机内存不够错误)、NotClassDefFoundError(类定义错误)。
- Exception:
  1. Uncheck Excption:RuntimeException及其子类都属于不受检查异常，如：NullPointerException(空指针异常）、ArithmeticException(算数异常)、ArrayIndexOutOfBoundsException(数组越界)、NumberFormatException(字符串转换为数字)、ClassCastException(类型转换错误)。
  2. 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于检查异常。常见的受检查异常有： IO 相关的异常、ClassNotFoundException 、SQLException…。
Throwable类常用方法
- public string getMessage():返回异常发生时的简要描述
- public string toString():返回异常发生时的详细信息
- public string getLocalizedMessage():返回异常对象的本地化信息。使用 Throwable 的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与 getMessage（）返回的结果相同
- public void printStackTrace():在控制台上打印 Throwable 对象封装的异常信息
3.异常处理总结
- try块：用于捕获异常，其后可跟0个或多个catch块，如果没有catch块，则必须跟一个finally块。
- **catch块：用于处理try捕获到的异常。
- finally块：无论是否捕获catch块，都会执行finally块，当try**，catch遇到return时，finally块会在方法返回之前被执行。
以下三种特殊情况下，finally不会被执行
1. 在try或finally块中用了system.exit(int)退出程序，但如果system.exit(int)是在异常后，finally还是会被执行。
2. 线程死亡
3. CPU关闭

14.获取用键盘输入常用的两种方法

方法1：通过Scanner

Scanner input = new Scanner(System.in);
String s  = input.nextLine();
input.close();

方法2：通过BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String s = input.readLine();

15.Java序列化和反序列化

概念：

Java序列化的意思就是将对象的状态转换为字节流，以后可以再由这些值转换为同样状态的对象，对象序列化是实现对象持久化的方法。反序列化就是根据这些保存的信息重建对象的过程。

序列化：将java对象转化为字节序列的过程
反序列化：将字节序列转化为java对象的过程

为什么要序列化和反序列化？

我们知道，当两个进程进行通信的时候，可以传送各种类型的数据包括文字、图片、视频等，这些数据都会以二进制数据序列的形式在网络上进行传送。同样的，当两个java进程进行网络通信的时候也可以传输java对象，发送方通过将对象序列化转换为字节序列后进行网络传送，接收方通过这些字节序列恢复出Java对象。这样的好处就是实现了数据持久化。

Java序列化中如果有些字段不想进行序列化，怎么办？

对于不项进行序列化的变量，使用transient关键字修饰。

transient关键字的作用是：阻止实例中哪些用词关键字修饰的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。

16.Java中IO流

Java中Io流分为几种？
- 按照流向分：分为输入流、输出流
- 按照操作单位来分：分为字节流、字符流
- 按照流的角色来分：分为节点流（直接与数据源相连，读入或读出，直接使用节点流读写不方便，为了更快的读写文件有了处理流）、处理流（处理流和节点流一块使用，在节点流的基础上在套接一层，套接在节点流上的就是处理流）
Java IO流的40多个类都是从如下4个抽象类基类中派生出来的。
- InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
- OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
既然有了字节流，为什么还要有字符流？（重要）
- Q: 本体本质是想问：不管是网络传送还是文件读写，信息的最小存储单元都是字节，那为什么IO流还要区分一个字节流和字符流？
A:字符流是由Java虚拟机将字节转换而成，问题是这个转换过程十分耗时，并且当我们不知道编码类型时可能会出现乱码，所以IO流干脆直接弄一个操作字符得接口，方便平时对字符进行流操作。当要处理的数据是音频文件、图片等媒体文件用字节流操作，要处理的数据涉及字符时用字符流操作。

17.深拷贝和浅拷贝

浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递。
深拷贝：对基本数据类型进行值传递，对引用数据类型创建一个新对象，并复制其内容。

二、集合

1.概念

对象的容器，实现了对对象常用的操作，类似数组功能

2.集合和数组的区别

数组场地固定，集合长度不固定
数组可以存储基本类型和引用类型，集合只能存储引用类型

3.Connection接口：

List：有序可重复
1. ArrayList:底层数据结构是数组
  - 优点：查询快，效率高
  - 缺点：增删慢，线程不安全
2. Vector:底层数据结构数组
  - 优点：查询快，线程安全
  - 缺点：增删慢，效率低
3. LinkedList:底层数据结构是链表
  - 优点：增删快，效率高
  - 缺点：查询慢，线程不安全
Set：无序，不可重复
1. HashSet：底层数据结构是哈希表
  - 如何保证元素唯一性：依赖两个方法hashCode()和equals()
2. LinkedHashSet：底层数据结构是哈希表和链表
  - 由哈希表来保证元素唯一
  - 由链表来保证有序
3. TreeSet：底层数据结构是哈希表和红黑树
  - 如何保证元素有序：自然排序比较器排序
  - 如何保证元素唯一：根据比较的返回值是否为0来保证
针对Collection集合选用谁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-keVMSe3z-1636290368117)(C:\Users\24557\AppData\Roaming\Typora\typora-user-images\image-20210819212507982.png)]

4.List、Set、Map的区别？

List：有序可重复
Set：无序，不可重复
Map：键值对，key无序，不可重复，value无序，可重复

5.ArrayList和LinkedList的区别

是否保证线程安全：二者都不同步，也就是不保证线程安全。
底层数据结构：ArrayList是数组，LinkedList是双向链表
插入和删除是否受元素影响：
- ArrayList采用数组存储，所以受元素影响，比如：执行add（E，e）操作时，会默认将指定元素插入队尾，**此时时间复杂度为O(1)。**但如果在指定为位置i执行插入和删除元素的话，时间复杂度就为O（n-i），因为第i个位置及该位置之后的元素都需要向后或向前移动一位。
- LinkedList采用链表存储，不受元素影响，add（E,e)近似为O(1)，在指定位置插入近似为O（n）。
是否支持随机访问：ArrayList支持 LinkedList不支持
内存空间占用：ArrayList的空间浪费体现在数组的末尾或预留一部分空间，LinkedList的空间浪费体现在每一个元素都需要多余的空间去存储它的直接前驱、直接后继和数据。

6.ArrayList 与 Vector 区别?为什么要用Arraylist取代Vector呢？

ArrayList是list的主要实现类，适用于频繁查找，线程不安全
Vector是list的古老实现类，线程安全
Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象。**但是一个线程访问Vector的话，代码要在同步操作上耗费大量的时间。**Arraylist不是同步的，所以在不需要保证线程安全时建议使用Arraylist。

7.说一说ArrayList的扩容机制吧

以无参构造方法构造ArrayList的时候，实际上初始化复制的还是一个空数组，当添加第一个元素时才开始真正分配容量，即向数组添加第一个元素的时候，初始容量+10，之后每次扩容1.5倍左右（旧容量+旧容量>>1)，如果是偶数就是刚好1.5倍，如果是奇数运算结果会丢掉小数部分

8.HashMap和HashTable的区别（重要）

线程是否安全：HashMap 是非线程安全的（要安全一般用ConcurreentHashMap），HashTable线程安全(因为内部的方法即被都经过synchronized修饰)
效率：HashMap由于是非线程安全的，效率要比HashTable要高一些，另外HashTable现在被淘汰了。
初始容量：如不定初值，HashMap的默认初始容量为16，每次扩容为原来的两倍，HashTable的默认初始容量为11，每次扩容为原来的2n+1

插一个问题：

Q：16是2的幂，8也是，32也是，为啥偏偏选了16？

A：个人觉得这可能就是一个经验值吧，只要是2的次幂，8和32应该都差不多，用16可能只是作者觉得16这个初始容量符合常用而已。防止分配过小频繁扩容，分配过大浪费资源。
是否支持Null的key和value：HashMap支持(但null作为key只可以有一个，作为value可以有多个），HashTable不支持(如果用null会报空指针异常)

HashTable之所以不可以用null是因为它采用的是安全失败机制，每一次获得的数据不是最新的，如果用null无法判断值是为空还是不存在，因为你无法再次调用contains（key）去判断，ConcurrentHashMap同理。
底层数据结构：HashMap为链表加红黑树，jdk1.8后为解决哈希冲突当链表大于等于阈值（默认为8）时会转换为红黑树，以减少搜索时间。（在转换为红黑树之前会进行一次判断，如果当前的数组长度小于64，会先对数据进行扩容）

tips:为减少链表和红黑树的频繁转换，取7为一个缓冲值，当链表长度小于等于6时会由红黑树转换为链表，当链表长度大于等于8时由链表转换为红黑树

Q：为什么取8这个数字？

A：根据泊松分布，在负载因子默认为0.75的时候，单个hash槽内元素个数为8的概率小于百万分之一，所以将7作为一个分水岭，等于7的时候不转换，大于等于8的时候才进行转换，小于等于6的时候就化为链表。

9.HashMap和HashSet的区别

HashSet底层就是由HashMap实现的

HashMap	HashSet
实现了Map接口	实现了Set接口
用put()方法添加元素	用add()方法添加元素
存储键值对	仅存储对象
使用键值对计算hashCode	使用对象计算hashCode,对于两个对象来说hashCode可能相同，所以用equals方法来判断对象是否相等。

10.HashMap的长度为什么总是2的幂次方？（即为什么HashMap扩容总是为扩大两倍？）

为保证HashMap尽可能高效，要求hash值尽可能散列以减少碰撞，这个散列值是非常大的，所以我们很容易就会想到用取模运算，可以用一个公式对这个取模运算进行优化一下，即hash%length==hash&(length-1),这样做的好处是位运算肯定是要比模运算效率要高一些的，而满足这个公式的前提就是length要为2的幂次方。

11.HashMap多线程操作导致死循环问题

主要原因在于并发下的Rehash会导致元素形成一个循环链表

12.ConcurrentHashMap和Hashtable的区别

底层数据结构：在JDK1.8之前，ConcurrentHashMap采用的是分段的数组+链表的形式，在Jdk1.8后跟HashMap一样，采用数组+链表/红黑树的形式。而Hashtable就是数组加链表。
实现线程安全的方式：
- Hashtable使用synchronized保证线程安全，是同一把锁，效率非常低，当一个线程并发访问同步方法时，其他线程可能会进入阻塞或轮询状态，比如一个线程使用put方法时，别的线程都不能使用了，竞争越来越激烈，效率越来越低。
- CouncurrentHashMap在jdk1.8之前使用的是分段锁，**即每一把锁只锁容器的一部分，这样就不会出现锁竞争，提高并发访问效率。**jdk1.8之后，摒弃了segment的概念，而是使用node数组+链表/红黑树，并发控制synchronized和CAS来操作。

13.比较HashSet、LinkedHashSet、TreeSet

HashSet是Set的接口的主要实现类，底层是由HashMap实现的，可以存null值，线程不安全。
LinkedHashSet是HashSet的子类，能够按照添加的顺序遍历。
TreeSet的底层是红黑树，排序方式有自然排序和定制排序。

三、JVM

1.什么是JVM？

JVM就是Java虚拟机，主要是通过在实际计算机中模拟计算机的各功能实现的
它是实现跨平台的核心
我们编写.java文件经过Java编译器编程.class文件，.class文件经过JVM解释给操作系统执行
由堆、方法区、虚拟机栈、本地方法栈、程序计数器组成。
有自己的指令集，解释自己的指令集到CPU指令集和系统资源中调用。

2.JVM内存区域划分

分为运行时数据区、执行引擎、类装载器

3.介绍一下Java内存区域（运行时数据区）

Java虚拟机在执行Java程序的过程中会把它管理的内存划分程若干个数据区域

在JDK1.8之前：

JDK1.8：

线程私有的：

虚拟机栈（为保证线程中的局部变量不被别的线程访问）
本地方法栈（为保证线程中的局部变量不被别的线程访问）
程序计数器（为保证线程切换后能恢复到正确的执行位置）

线程共享的：

堆
方法区

<1>程序计数器：

字节码解释器用程序计数器的值来执行下一条需要解释的指令
在多线程中，当切换回该线程时通过程序计数器知道上一次执行到哪个位置，所以程序计数器时线程私有的，每一个线程都有一个自己的程序计数器。
JVM中唯一没有规定OutOfMemoryError情况的区域

<2>Java虚拟机栈：

Java虚拟机栈也是线程私有的，它的生命周期与线程相同
如果线程所申请的深度大于虚拟机所允许的深度会报StackOverFlowError，如果虚拟机栈可动态扩充内存，如果扩展无法申请到足够的内存会报OutOfMemoryError
Java虚拟机栈描述的是Java方法执行的内存模型，每隔方法在执行的同时都会创建一个栈帧用于存储局部变量表、操作数栈等信息。每一个方法从调用直至完成的过程就对应着一虚拟机栈入栈到出栈的过程。

Java方法有两种返回方式：

return语句
抛出异常

不管是哪种返回方式都会导致栈帧被弹出。

<3>本地方法栈：

与虚拟机栈所发挥的作用非常相似，区别是虚拟机栈为Java方法（也就是字节码服务，而本地方法栈则为虚拟机使用到的Native方法服务。

<4>堆：

此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例和数组都存放在堆空间

Java中几乎所有对象都放在堆中，但随着JIT编译器的发展与逃逸分析技术逐渐成熟，将会导致一些微妙的变化，所有对象都分配到堆中变的不那么绝对了，从JDK1.7开始，已经默认开始逃逸分析，如果某些方法的对象引用没有被返回，是有可能在栈上分配内存的。
Java堆是垃圾收集器管理的主要区域，因此也被称作GC堆。由于现在垃圾回收器的分代垃圾回收算法，堆还可以被细分为：
- 新生代：
  其中新生代又可分为：
  - eden空间
  - From survivor空间
  - To Survivor空间
- 老生代
- 永生代（JDK8之后的永生代被彻底移除了，取而代之的是元空间，元空间使用的是直接内存）

<5>方法区：

方法区与Java堆一样是线程共享的内存区域，用于存储已被虚拟机加载的类信息。

方法区与永生代的关系：

《Java虚拟机规范》只是规定了有方法区这么个概念，但并没有说明如何实现，永生代相当于是HotSpot虚拟机中对方法区的一个实现，别的虚拟机中没有这样的概念。
常用参数：

在永生代没有被彻底移除前通常用这样的参数来调节方法区的大小：

-XX:PermSize=N //永生代初始大小

-XX：MaxPermSize=N //永生代最大大小

永生代被彻底移除后，取而代之的是元空间，云空间使用的是直接内存

-XX：MetaspaceSize=N//元空间初始大小

-XX：MetaspaceSize=N//元空间最大大小
为什么要将永久代替换为元空间呢？

整个永久代有一个JVM本身设置的固定上限，无法调整，元空间使用的是直接内存，受本机可用内存的限制，虽然还是有可能会移溢出，但几率比永久代要小多了

 一句话简单了解堆和方法区

堆和方法区是所有线程共享的资源，其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

<6>运行时常量池：

运行时常量吃是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有常量池表。

<7>直接内存：

直接内存并不是虚拟机运行时数据区的一部分，也不是虚拟机规范中定义的内存区域，但是这部分内存也被频繁的使用。而且也可能导致OutOfMemoryError错误出现。

4.说一下Java对象的创建过程

类加载检查、分配内存空间、初始化零值、设置对象头、执行init方法

5.聊聊JVM内存对象分配与回收

JVM主要是针对对象的分配和对象内存的回收的，这个过程主要发生在Java堆里，所以Java堆有时也称GC堆，由于现在垃圾回收器的分代算法，所以Java堆分为新生代（又分eden区、From survivor区、To survivor区）、老生代、永生代（在jdk1.8后被改成元空间）。大部分情况，一个对象的分配发生在eden区，当一次垃圾回收结束后，剩下的对象会进入From survivor区（或To survivor区），并且年龄+1，每从一个区跨到另一个各区年龄会加一，（经过这一次GC后，From区会变成To区，To区会变成From区，保证每次To都是空的，直到To区被填满，当被填满后全部送入老生代。）以此类推当年龄达到15岁后进入老生代。

6.说一下堆内存中对象的分配策略

对象在eden区优先分配
大对象直接进入老生代（字符串、数组）:避免分配担保机制带来的复制降低效率

什么是分配担保机制？

举个例子：现实中借钱有担保人，当欠债人不够还钱时，就由这个担保人还钱

同样的内存分配担保机制就是在对象在新生代分配内存，当新生代空间不够又有新的对象分配需要分配的时候，会把新生代里的对象全部移到老生代中，腾出空间给新的对象分配。
长期存活的对象进入老生代

7.如何判断对象是否死亡？

**引用计数法：**用一个计数器，当一个对象被引用的时候计数器+1，对象引用结束后计数器-1，任何时候计数器为0的对象都是不再被引用的了。
可达性分析算法：这个算法的思想时从“GC root”作为起点，从这些节点向下开始搜索，当一个对象没有引用链的时候就是死亡了。

8.强引用、软引用、弱引用、虚引用

引用：如果reference类型数据的值代表另一个数据的内存地址，就称这块内存为引用“

强引用：类似于必不可少的生活用品，GC时，绝不会回收它，内存空间足时，虚拟机宁可抛出OOM也不会回收它
软引用：类似于可有可无的生活用品，当内存空间不足时GC会回收它。

可加速JVM对垃圾内存的回收速度，维护系统安全，防止OOM
弱引用：类似于可有可无的生活用品，跟软引用区别在于，不管内存空间足不足，GC一旦发现都会回收它
虚引用：虚引用并不能决定对象的生命周期，如果一个对象只有虚引用，跟没有引用差不多，虚引用主要用来跟踪对象被垃圾回收的活动。

9.如何判断一个常量时废弃常量？

运行时常量池主要回收的时废弃的常量，假设有个常量”abc“，当它没有被任何String对象引用时，就说明”abc“是废弃常量。

10.如何判断一个类是无用的类？

该类所有实例被回收
该类加载器被回收
该类对应的java.lang.class对象没有被任何地方引用

11.垃圾收集有哪些算法？

标记-清楚算法：标记处所有不需要回收的对象，标记完后统一回收未标记的对象。最基础
复制算法：把一片内存分成两片大小相同的空间，当一块内存使用完后，将还能存活的复制到另一边，剩下的进行回收。每次可以对内存区间的一半进行回收。（适用于新生代）
标记整理算法：跟标记清楚类似，不过后续的处理是让可存活的移向一端，然后直接清理掉边界以外的内存。

12.常见垃圾回收器：

并发：同一时间段，多个任务都在执行（单位时间内不一定同时执行）

并行：同一时间段，多个任务同时执行

在这里：

并行：多条垃圾回收线程并行，但用户线程暂停等待

并发：垃圾回收线程和用户线程同时执行（不一定是并行，有可能交替执行）

serial收集器：单线程，Stop The World，运行时其他工作线程必须暂停，直至垃圾回收结束
ParNew收集器：serial收集器的多线程版本
Paraller Scavenge收集器：在ParNew的基础上提高吞吐量（运行用户代码时间和CPU总消耗时间的比值）
serial old收集器：serial的老年代版本
Paraller old收集器：Paraller的老年代版本
**CMS（Councurrent Mark Sweep）收集器： ** 低停顿、高吞吐量
- 初始标记
- 并发标记
- 重新标记
- 并发清除
优点：并发收集、低停顿

缺点：标记清除算法会产生很多空间碎片、无法处理浮动垃圾
G1收集器：
- 初始标记
- 并发标记
- 最终标记
- 筛选回收

四、多线程

1.并发和并行的区别

并发：一段时间内，多个任务都在执行（单位时间内不一定是同时执行）
并行：单位时间内，多个任务同时执行

2.为什么要使用多线程？

多线程可以理解为轻量级进程，是程序执行的最小单位，在多核CPU时代，多线程可以同时进行，可以减少线程上下文切换的开销
利用好多线程，可以提高CPU的利用率，可以提高系统的整体并发能力和性能

3.多线程可能带来哪些问题？

内存泄露、上下文切换、死锁

4.什么是上下文切换？

多线程下一般线程数量都会多过CPU数量，而一个CPU只能处理一个线程，所以CPU采取给线程安排时间片轮转的形式来运行线程，一个线程时间片轮转完切换到下一个线程，这个过程叫做一次上下文切换。
概括的来说就是，当前任务在执行完CPU时间后，线程会先保存自己的状态以便下次切换回来继续执行该线程，保存完后CPU切换到另一个线程，这个保存到加载另一个线程的过程就是上下文切换。

5.什么是死锁？

两个线程都想互相占有对方所持有的资源，而导致持续等待的一个现象，如果没有外力作用，两个线程会一直无法推进。

6.产生死锁的四个条件？

互斥条件：该资源在任意时刻只有一个进程占有
请求与保持条件：当一个进程申请别的资源的时候，可以保持自己所持有的资源
不剥夺条件：当一个进程占有一个资源时，该资源不能被其他进程所剥夺
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

7.如何避免产生死锁？

破坏互斥条件：无法破坏（因为我们用锁本来就是为了让他们互斥）
破坏请求与保持条件：一次性把所需要的资源都同时申请了
破坏不剥夺条件：一个资源在申请其他资源的时候，如果申请不到，可以释放自己所占有的资源
破坏循环等待条件：所有进程按序申请资源

8.说说sleep()方法和wait()方法的区别

slepp方法不释放锁，而wait方法释放锁
两者都可被用于暂停线程，sleep多用于暂停，wait多用于线程间交互/通信
sleep结束后可以自动苏醒，wait不可以，需要别的线程调用对象的notify，如果想自己苏醒需要用wait（long timeout）

9.说一下为什么我们调用start()方法时start调用了run方法，为什么不能直接执行run方法？

调用start方法可启动线程并让它处于就绪状态，而直接调用run方法，会以main方法下的一个普通方法去运行，并不会在某个线程中执行它，并没有实现多线程。

10.说一下对synchronized这个关键字的了解

在Java早期版本中，synchronized是一个重量级锁，效率低下，因为每次实现线程之间的转换都需要操作系统帮忙，这个时间消耗很久，在java6之后，Java对其进行了很多优化，现在synchronized锁定的效率已经优化的不错了。

11.为什么要用一个CPU告诉缓存？

为了解决CPU处理速度和内存处理速度不对等，内存缓存的是硬盘数据，用来解决硬盘访问速度过慢的问题

12.说说synchronized和volatile的区别？

volatile是synchronized的轻量级实现，性能比synchronized要好，但是volatile只能修饰变量而synchronized可以修饰方法、代码块。

13.了解ThreadLocal吗？

通常来说我们定义的变量是可以被任何线程访问的，ThreadLocal给每个线程都提供了自己装专属本地变量的地方，从而避免线程安全问题。

ThreadLocal底层是由ThreadLocalMap，key对象ThreadLocal对象，value对应set方法设置的值

14.ThreadLocal内存泄漏问题？

底层的ThreadLocalMap中key是弱应用，value是强引用，如果ThreadLocal没有被外部强引用的情况下，由于value是强引用（必不可少的生活品），所以难以被GC清理，而key是弱引用（可有可无的生活品），一轮GC后就被回收了，这样就会出现key为null的键值对。

15.为什么要用线程池？

池化思想：

减少每次资源的消耗，提高资源利用率
线程池的好处：
1. 降低资源的消耗：用线程池中创建过的线程可以避免频繁创建线程造成的资源消耗。
2. 提高响应速度：直接采用线程池中的线程，用户不需用等待线程的创建。
3. ***提高线程的可管理性：***线程是稀缺资源，频繁的创建不仅会导致资源浪费还会降低系统的稳定性，用线程池可以对线程进行统一分配，监控，调优。

16.AQS了解吗？

AQS(AbstractQueuedSynchronizer)：是一个构建锁和同步器的框架
原理：

AQS的核心思想是，如果请求的资源空闲，就把该请求资源的线程设置为工作线程，并给它配置一把锁。如果请求的资源被占有，那么就需要一套线程阻塞等待以及线程唤醒后锁分配的机制，这个机制是由CLH队列来实现的，CLH队列是一个虚拟的双向队列，将暂时获取不到锁的线程放入该队列中。