2023最新最全国内大厂Java面试高频题库

小灰灰 2023-10-16 13:07 20阅读 0赞

### 前言 ###

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16]

### 一、基础篇 ###

#### 1.1.Java语言有哪些特点 ####

> 1、简单易学、有丰富的类库  
> 2、面向对象（Java最重要的特性，让程序[耦合度][Link 1]更低，内聚性更高）  
> 3、与平台无关性（JVM是Java跨平台使用的根本）  
> 4、可靠安全  
> 5、支持多线程

#### 1.2.面向对象和[面向过程][Link 2]的区别 ####

> **面向过程**：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调用则可。性能较高，所以单片机、[嵌入式开发][Link 3]等一般采用面向过程开发  
> **面向对象**：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特性，所以易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。

> #### 本小册内容涵盖：Java基础，JVM，多线程，数据库（MySQL/Redis）SSM，Dubbo，网络，MQ，Zookeeper，Netty，微服务，大数据，算法，项目，设计模式等，篇幅足足近2千页，大家面试前拿去提前刷刷，肯定能对你们有很大帮助！ ####

#### **篇幅限制下面就只能给大家展示小册部分内容了，需要完整版的小伙伴点赞+收藏，关注在本文，【文尾点击名片】即可免费获取** ####

####  ####

#### 1.3.八种基本数据类型的大小，以及他们的封装类 ####

<table> 
 <thead> 
  <tr> 
   <th>基本类型</th> 
   <th>大小（字节）</th> 
   <th>默认值</th> 
   <th>封装类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>1</td> 
   <td>(byte)0</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>2</td> 
   <td>(short)0</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>4</td> 
   <td>0</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>8</td> 
   <td>0L</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>4</td> 
   <td>0.0f</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>8</td> 
   <td>0.0d</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>-</td> 
   <td>false</td> 
   <td>Boolean</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>2</td> 
   <td>\u0000(null)</td> 
   <td>Character</td> 
  </tr> 
 </tbody> 
</table>

注：

> 1.int是基本数据类型，Integer是int的封装类，是引用类型。int默认值是0，而Integer默认值是null，所以Integer能区分出0和null的情况。一旦java看到null，就知道这个引用还没有指向某个对象，再任何引用使用前，必须为其指定一个对象，否则会报错。  
> 2.基本数据类型在声明时系统会自动给它分配空间，而引用类型声明时只是分配了引用空间，必须通过实例化开辟数据空间之后才可以赋值。数组对象也是一个引用对象，将一个数组赋值给另一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看的见。  
> 虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean元素  
> 占8位。这样我们可以得出boolean类型占了单独使用是4个字节，在数组中又是1个字节。使用int的原因是，对于当下32位的处理器（CPU）来说，一次处理数据是32位（这里不是指的是32/64位系统，而是指CPU硬件层面），具有高效存取的特点。

#### 1.4.标识符的命名规则。 ####

> **标识符的含义：**  
> 是指在程序中，我们自己定义的内容，譬如，类的名字，方法名称以及变量名称等等，都是标识符。  
> **命名规则：（硬性要求）**  
> 标识符可以包含英文字母，0-9的数字，$以及\_  
> 标识符不能以数字开头  
> 标识符不是关键字  
> **命名规范：（非硬性要求）**  
> 类名规范：首字符大写，后面每个单词首字母大写（大驼峰式）。  
> 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。  
> 方法名规范：同变量名。

#### 1.5.instanceof 关键字的作用 ####

instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：

boolean result = obj instanceof Class

*  1
 *  2

> 其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。  
> 注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。

int i = 0;
    System.out.println(i instanceof Integer);//编译不通过 i必须是引用类型，不能是基本类型
    System.out.println(i instanceof Object);//编译不通过
    
    Integer integer = new Integer(1);
    System.out.println(integer instanceof  Integer);//true
    
    //false ,在 JavaSE规范 中对 instanceof 运算符的规定就是：如果 obj 为 null，那么将返回false。
    System.out.println(null instanceof Object);

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10

#### 1.6.Java自动装箱与拆箱 ####

> **装箱**就是自动将基本数据类型转换为包装器类型（int–>Integer）；调用方法：`Integer`的`valueOf(int)` 方法  
> **拆箱**就是自动将包装器类型转换为基本数据类型（Integer–>int）。调用方法：`Integer`的`intValue`方法

在Java SE5之前，如果要生成一个数值为10的`Integer`对象，必须这样进行：

Integer i = new Integer(10);

*  1
 *  2

而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了：

Integer i = 10;

*  1
 *  2

面试题1： 以下代码会输出什么？

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);
     }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13

运行结果:

true
    false

*  1
 *  2
 *  3

为什么会出现这样的结果？输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。此时只需一看源码便知究竟，下面这段代码是Integer的valueOf方法的具体实现：

public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
          return IntegerCache.cache[i + 128];
        else
          return new Integer(i);
     }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7

其中IntegerCache类的实现为：

private static class IntegerCache {
        static final int high;
        static final Integer cache[];
        static {
          final int low = -128;
          // high value may be configured by property
          int h = 127;
          if (integerCacheHighPropValue != null) {
            // Use Long.decode here to avoid invoking methods that
            // require Integer's autoboxing cache to be initialized
            int i = Long.decode(integerCacheHighPropValue).intValue();
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - -low);
         }
          high = h;
          cache = new Integer[(high - low) + 1];
          int j = low;
          for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
       }
        private IntegerCache() {}
     }

![c511b28b433643914eb81fe9985d52a0.png][]

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24

从这2段代码可以看出，在通过`valueOf`方法创建`Integer`对象的时候，如果数值在\[-128,127\]之间，便返回指向`IntegerCache.cache`中已经存在的对象的引用；否则创建一个新的`Integer`对象。  
上面的代码中i1和i2的数值为100，因此会直接从`cache`中取已经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是分别指向不同的对象。  
面试题2：以下代码输出什么？

public class Main {
      public static void main(String[] args) {
       
        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
       
        System.out.println(i1==i2);
        System.out.println(i3==i4);
     }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13

运行结果：

false
    false

*  1
 *  2
 *  3

原因： 在某个范围内的整型数值的个数是有限的，而浮点数却不是。

#### 1.7.重载和重写的区别 ####

**重写(Override)**

> 从字面上看，重写就是重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。

public class Father {
      public static void main(String[] args) {
        // TODO Auto-generated method stub
        Son s = new Son();
        s.sayHello();
     }
      public void sayHello() {
        System.out.println("Hello");
     }
    }
    class Son extends Father{
      @Override
      public void sayHello() {
        // TODO Auto-generated method stub
        System.out.println("hello by ");
     }
    }

![70ad83bfc59fc217af5b8d0bea7e9ae8.png][]

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17

**重写总结：**

> 1.发生在父类与子类之间  
> 2.方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同  
> 3.访问修饰符的限制一定要大于被重写方法的访问修饰符`(public>protected>default>private)`  
> 4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常

**重载（Overload）**

> 在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。

public class Father {
      public static void main(String[] args) {
        // TODO Auto-generated method stub
        Father s = new Father();
        s.sayHello();
        s.sayHello("wintershii");
     }
      public void sayHello() {
        System.out.println("Hello");
     }
      public void sayHello(String name) {
        System.out.println("Hello" + " " + name);
     }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14

**重载总结：**

> 1.重载`Overload`是一个类中多态性的一种表现  
> 2.重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)  
> 3.重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

#### 1.8.equals与==的区别 ####

**== ：**

> `==` 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。  
> 1、比较的是操作符两端的操作数是否是**同一个对象**。  
> 2、两边的操作数必须是**同一类型**的（可以是父子类之间）才能编译通过。  
> 3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：  
> int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。

**equals：**

> `equals`用来比较的是两个对象的内容是否相等，由于所有的类都是继承自`java.lang.Object`类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是`Object`类中的方法，而`Object`中的`equals`方法返回的却是`==`的判断。

**总结：**

> 所有比较是否相等时，都是用`equals` 并且在对常量相比较时，把常量写在前面，因为使用`object`的`equals object`可能为null 则空指针在阿里的代码规范中只使用`equals` ，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来排  
> 查老代码使用`“==”`，替换成`equals`

#### 1.9.Hashcode的作用 ####

> java的集合有两类，一类是`List`，还有一类是`Set`。**前者有序可重复，后者无序不重复**。当我们在set中插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法就会比较满。  
> 于是有人发明了哈希算法来提高集合中查找元素的效率。 这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储的那个区域。  
> hashCode方法可以这样理解：**它返回的就是根据对象的内存地址换算出的一个值**。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。  
> 如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

#### 1.10.String、String StringBuffer 和 StringBuilder 的区别是什么? ####

> `String`是只读字符串，它并不是基本数据类型，而是一个对象。从底层源码来看是一个`final类型`的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对`String`的操作都会生成新的`String`对象。

private final char value[];

*  1

每次+操作 ： 隐式在堆上new了一个跟原字符串相同的`StringBuilder`对象，再调用`append`方法 拼接+后面的字符。  
`StringBuffer`和`StringBuilder`他们两都继承了`AbstractStringBuilder`抽象类，从`AbstractStringBuilder`抽象类中我们可以看到

/**
      * The value is used for character storage.
      */
      char[] value;

*  1
 *  2
 *  3
 *  4

> 他们的底层都是可变的**字符数组**，所以在进行频繁的字符串操作时，建议使用`StringBuffer`和`StringBuilder`来进行操作。 另外`StringBuffer` 对方法加了同步锁或者对调用的方法加了**同步锁**，所以是**线程安全**的。`StringBuilder` 并没有对方法进行加**同步锁**，所以是**非线程安全的**。

#### 1.11.ArrayList和linkedList的区别 ####

> Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。  
> Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有数据,(因为删除数据以后, 需要把后面所有的数据前移)  
> **缺点**: 数组初始化必须指定初始化的长度, 否则报错

例如:

int[] a = new int[4];//推介使用int[] 这种方式初始化
    int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]

*  1
 *  2
 *  3

> `List`—是一个**有序的集合**，可以**包含重复**的元素，提供了按索引访问的方式，它继承`Collection`。  
> `List`有两个重要的实现类：`ArrayList`和`LinkedList`  
> `ArrayList`: 可以看作是能够自动增长容量的数组  
> `ArrayList`的`toArray`方法返回一个数组  
> `ArrayList`的`asList`方法返回一个列表  
> `ArrayList`底层的实现是`Array`, 数组扩容实现  
> `LinkList`是一个双链表,在添加和删除元素时具有比`ArrayList`更好的性能.但在`get`与`set`方面弱于`ArrayList`.当然,这些对比都是指数据量很大或者操作很频繁。

#### 1.12.HashMap和HashTable的区别 ####

> 1、**两者父类不同**  
> `HashMap`是继承自`AbstractMap`类，而`Hashtable`是继承自`Dictionary`类。不过它们都实现了同时实现了`map、Cloneable（可复制）、Serializable（可序列化）`这三个接口。  
> 2、**对外提供的接口不同**  
> `Hashtable`比`HashMap`多提供了`elments() 和contains()` 两个方法。  
> `elments()` 方法继承自`Hashtable`的父类`Dictionnary`。`elements()` 方法用于返回此`Hashtable`中的value的枚举。  
> `contains()`方法判断该`Hashtable`是否包含传入的value。它的作用与`containsValue()`一致。事实上，`contansValue()` 就只是调用了一下`contains()` 方法。  
> 3、**对null的支持不同**  
> `Hashtable`：`key`和`value`都不能为`null`。  
> `HashMap`：`key`可以为`null`，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的`value`为`null`。  
> 4、**安全性不同**  
> `HashMap`是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。  
> `Hashtable`是线程安全的，它的每个方法上都有`synchronized` 关键字，因此可直接用于多线程中。  
> 虽然`HashMap`是线程不安全的，但是它的效率远远高于`Hashtable`，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的`ConcurrentHashMap`。  
> `ConcurrentHashMap`虽然也是线程安全的，但是它的效率比`Hashtable`要高好多倍。因为`ConcurrentHashMap`使用了分段锁，并不对整个数据进行锁定。  
> 5、**初始容量大小和每次扩充容量大小不同**  
> 6、**计算hash值的方法不同**

#### 1.13.Collection包结构，与Collections的区别 ####

`Collection`是集合类的上级接口，子接口有 `Set、List、LinkedList、ArrayList、Vector、Stack、Set`；  
Collections是集合类的一个帮助类， 它包含有各种有关集合操作的静态多态方法，用于实现对各种集合的搜索、排序、线程安全化等操作。此类不能实例化，就像一个工具类，服务于Java的`Collection`框架。

#### 1.14. Java的四种引用，强弱软虚 ####

**强引用:**  
强引用是平常中使用最多的引用，强引用在程序内存不足（OOM）的时候也不会被回收，使用方式：

String str = new String("str");

*  1
 *  2

**软引用**  
软引用在程序内存不足时，会被回收，使用方式：

// 注意：wrf这个引用也是强引用，它是指向SoftReference这个对象的，
    // 这里的软引用指的是指向new String("str")的引用，也就是SoftReference类中T
    SoftReference<String> wrf = new SoftReference<String>(new String("str"));

*  1
 *  2
 *  3

**可用场景：** 创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM就会回收早先创建的对象。

**弱引用**  
弱引用就是只要JVM垃圾回收器发现了它，就会将之回收，使用方式：

WeakReference<String> wrf = new WeakReference<String>(str);

*  1

**可用场景**： Java源码中的 java.util.WeakHashMap 中的 key 就是使用弱引用，我的理解就是，**一旦我不需要某个引用，JVM会自动帮我处理它，这样我就不需要做其它操作。**

**虚引用**  
虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入`ReferenceQueue` 中。注意哦，其它引用是被JVM回收后才被传入`ReferenceQueue` 中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有 `ReferenceQueue` ，使用

例子：

PhantomReference<String> prf = new PhantomReference<String>(new String("str"), new ReferenceQueue<>());

*  1

可用场景： 对象销毁前的一些操作，比如说资源释放等。`Object.finalize()` 虽然也可以做这类动作，但是这个方式即不安全又低效  
上诉所说的几类引用，都是指对象本身的引用，而不是指 `Reference` 的四个子类的引用( `SoftReference` 等)。

#### 1.15.泛型常用特点 ####

泛型是Java SE 1.5之后的特性， 《Java 核心技术》中对泛型的定义是：

> “泛型” 意味着编写的代码可以被不同类型的对象所重用。

“泛型”，顾名思义，“泛指的类型”。我们提供了泛指的概念，但具体执行的时候却可以有具体的规则来约束，比如我们用的非常多的ArrayList就是个泛型类，ArrayList作为集合可以存放各种元素，如`Integer, String`，自定义的各种类型等，但在我们使用的时候通过具体的规则来约束，如我们可以约束集合中只存放Integer类型的元素，如

List<Integer> iniData = new ArrayList<>();

*  1

使用泛型的好处？

> 以集合来举例，使用泛型的好处是我们不必因为添加元素类型的不同而定义不同类型的集合，如整型集合类，浮点型集合类，字符串集合类，我们可以定义一个集合来存放整型、浮点型，字符串型数据，而这并不是最重要的，因为我们只要把底层存储设置了Object即可，添加的数据全部都可向上转型为Object。 更重要的是我们可以通过规则按照自己的想法控制存储的数据类型。

#### 1.16.Java创建对象有几种方式？ ####

java中提供了以下四种创建对象的方式:

> new创建新对象  
> 通过反射机制  
> 采用clone机制  
> 通过序列化机制

#### 1.17.有没有可能两个不相等的对象有相同的hashcode ####

有可能.在产生`hash`冲突时,两个不相等的对象就会有相同的 `hashcode` 值.当`hash`冲突产生时,一般有以下几种方式来处理:

> **拉链法**:每个哈希表节点都有一个next指针,多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表进行存储.  
> **开放定址法**:一旦发生了冲突,就去寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到,并将记录存入  
> **再哈希**:又叫**双哈希法**,有多个不同的Hash函数.当发生冲突时,使用第二个,第三个….等哈希函数计算地址,直到无冲突.

#### 1.18.深拷贝和浅拷贝的区别是什么? ####

> **浅拷贝**:被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象.换言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象.  
> **深拷贝**:被复制对象的所有变量都含有与原来的对象相同的值.而那些引用其他对象的变量将指向被复制过的新对象.而不再是原有的那些被引用的对象.换言之.深拷贝把要复制的对象所引用的对象都复制了一遍.

#### 1.19.final有哪些用法? ####

final也是很多面试喜欢问的地方,但我觉得这个问题很无聊,通常能回答下以下5点就不错了:

> 1.被final修饰的类不可以被继承  
> 2.被final修饰的方法不可以被重写  
> 3.被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.  
> 4.被final修饰的方法,JVM会尝试将其内联,以提高运行效率  
> 5.被final修饰的常量,在编译阶段会存入常量池中.

除此之外,编译器对final域要遵守的两个重排序规则更好:

> 在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序  
> 初次读一个包含final域的对象的引用,与随后初次读这个final域,这两个操作之间不能重排序.

#### 1.20.static都有哪些用法? ####

所有的人都知道static关键字这两个基本的用法:静态变量和静态方法.也就是被static所修饰的变量/方法都属于类的静态资源,类实例所共享.

除了静态变量和静态方法之外,static也用于静态块,多用于初始化操作:

public calss PreCache{
      static{
        //执行相关操作
     }
    }

*  1
 *  2
 *  3
 *  4
 *  5

> 此外static也多用于修饰内部类,此时称之为静态内部类.  
> 最后一种用法就是静态导包,即 import static .import static是在JDK 1.5之后引入的新特性,可以用来指定导入某个类中的静态资源,并且不需要使用类名,可以直接使用资源名,比如:

import static java.lang.Math.*;
    public class Test{
      public static void main(String[] args){
        //System.out.println(Math.sin(20));传统做法
        System.out.println(sin(20));
     }
    }
    1234567

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8

#### 1.21.3\*0.1==0.3返回值是什么 ####

false,因为有些浮点数不能完全精确的表示出来.

#### 1.22.a=a+b与a+=b有什么区别吗? ####

\+= 操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型,而a=a+b则不会自动进行类型转换.如：

byte a = 127;
    byte b = 127;
    b = a + b; // 报编译错误:cannot convert from int to byte
    b += a;

*  1
 *  2
 *  3
 *  4
 *  5

以下代码是否有错,有的话怎么改？

short s1= 1;
    s1 = s1 + 1;

*  1
 *  2
 *  3

有错误.`short`类型在进行运算时会自动提升为int类型,也就是说 s1+1 的运算结果是int类型,而s1是`short`类型,此时编译器会报错.  
正确写法：

short s1= 1;
    s1 += 1;

*  1
 *  2
 *  3

\+=操作符会对右边的表达式结果强转匹配左边的数据类型,所以没错.

#### 1.23.try catch finally，try里有return，finally还执行么？ ####

执行，并且`finally`的执行早于`try`里面的`return`  
结论：

> 1、不管有木有出现异常，`finally`块中代码都会执行；  
> 2、当`try`和`catch`中有`return`时，`finally`仍然会执行；  
> 3、`finally`是在`return`后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管`finally`中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在`finally`执行前确定的；  
> 4、`finally`中最好不要包含`return`，否则程序会提前退出，返回值不是`try`或`catch`中保存的返回值

#### 1.24.Excption与Error包结构 ####

Java可抛出(`Throwable`)的结构分为三种类型：被检查的异常(`CheckedException`)，运行时异常(`RuntimeException`)，错误(`Error`)。

> 1、**运行时异常**  
> 定义:`RuntimeException`及其子类都被称为运行时异常。  
> 特点:Java编译器不会检查它。也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws声明抛出它"，也"没有用`try-catch`语句捕获它"，还是会编译通过。例如，除数为零时产生的`ArithmeticException`异常，数组越界时产生的`IndexOutOfBoundsException`异常，`fail-fast`机制产生的`ConcurrentModificationException`异常（`java.util`包下面的所有的集合类都是快速失败的，“快速失败”也就是fail-fast，它是Java集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast机制。记住是有可能，而不是一定。例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出`ConcurrentModificationException` 异常，从而产生fail-fast机制，这个错叫并发修改异常。Fail-safe，`java.util.concurrent`包下面的所有的类都是安全失败的，在遍历过程中，如果已经遍历的数组上的内容变化了，迭代器不会抛出`ConcurrentModificationException`异常。如果未遍历的数组上的内容发生了变化，则有可能反映到迭代过程中。这就是`ConcurrentHashMap`迭代器弱一致的表现。  
> `ConcurrentHashMap`的弱一致性主要是为了提升效率，是一致性与效率之间的一种权衡。要成为强一致性，就得到处使用锁，甚至是全局锁，这就与`Hashtable`和同步的`HashMap`一样了。）等，都属于运行时异常。

常见的五种运行时异常：

> ClassCastException（类转换异常）  
> IndexOutOfBoundsException（数组越界）  
> NullPointerException（空指针异常）  
> ArrayStoreException（数据存储异常，操作数组是类型不一致）  
> BufferOverflowException

> 2、**被检查异常**  
> 定义:`Exception`类本身，以及`Exception`的子类中除了"运行时异常"之外的其它子类都属于被检查异常。  
> 特点 : Java编译器会检查它。 此类异常，要么通过`throws`进行声明抛出，要么通过try-catch进行捕获处理，否则不能通过编译。例如，`CloneNotSupportedException`就属于被检查异常。当通过clone()接口去克隆一个对象，而该对象对应的类没有实现`Cloneable`接口，就会抛出`CloneNotSupportedException`异常。被检查异常通常都是可以恢复的。  
> 如：  
> IOException  
> FileNotFoundException  
> SQLException  
> 被检查的异常适用于那些不是因程序引起的错误情况，比如：读取文件时文件不存在引发的`FileNotFoundException` 。然而，不被检查的异常通常都是由于糟糕的编程引起的，比如：在对象引用时没有确保对象非空而引起的`NullPointerException` 。  
> 3、**错误**  
> 定义 : Error类及其子类。  
> 特点 : **和运行时异常一样，编译器也不会对错误进行检查。**  
> 当资源不足、约束失败、或是其它程序无法继续运行的条件发生时，就产生错误。程序本身无法修复这些错误的。例如，`VirtualMachineError`就属于错误。出现这种错误会导致程序终止运行。  
> `OutOfMemoryError、ThreadDeath`。  
> Java虚拟机规范规定JVM的内存分为了好几块，比如堆，栈，程序计数器，方法区等

#### 1.25.OOM你遇到过哪些情况，SOF你遇到过哪些情况 ####

OOM：

> 1，**`OutOfMemoryError`异常**  
> 除了程序计数器外，虚拟机内存的其他几个运行时区域都有发生`OutOfMemoryError(OOM)`异常的可能。  
> Java Heap 溢出：  
> 一般的异常信息：`java.lang.OutOfMemoryError:Java heap spacess`。  
> java堆用于存储对象实例，我们只要不断的创建对象，并且保证`GC Roots`到对象之间有可达路径来避免垃圾回收机制清除这些对象，就会在对象数量达到最大堆容量限制后产生内存溢出异常。  
> 出现这种异常，一般手段是先通过内存映像分析工具(如`Eclipse Memory Analyzer`)对`dump`出来的堆转存快照进行分析，重点是确认内存中的对象是否是必要的，先分清是因为内存泄漏(`Memory Leak`)还是内存溢出(`Memory Overflow`)。  
> 如果是内存泄漏，可进一步通过工具查看泄漏对象到`GCRoots`的引用链。于是就能找到泄漏对象是通过怎样的路径与`GC Roots`相关联并导致垃圾收集器无法自动回收。  
> 如果不存在泄漏，那就应该检查**虚拟机的参数(-Xmx与-Xms)的设置是否适当**。  
> 2，**虚拟机栈和本地方法栈溢出**  
> 如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出`StackOverflowError`异常。  
> 如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出`OutOfMemoryError`异常  
> 这里需要注意当**栈的大小越大可分配的线程数就越少**。  
> 3，**运行时常量池溢出**  
> **异常信息**：`java.lang.OutOfMemoryError:PermGenspace`  
> 如果要向运行时常量池中添加内容，最简单的做法就是使用`String.intern()`这个Native方法。该方法的作用是：如果池中已经包含一个等于此String的字符串，则返回代表池中这个字符串的String对象；否则，将此String对象包含的字符串添加到常量池中，并且返回此String对象的引用。由于常量池分配在方法区内，我们可以通过`-XX:PermSize和-XX:MaxPermSize`限制方法区的大小，从而间接限制其中常量池的容量。  
> 4，**方法区溢出**  
> 方法区用于存放Class的相关信息，如类名、访问修饰符、常量池、字段描述、方法描述等。也有可能是方法区中保存的class对象没有被及时回收掉或者class信息占用的内存超过了我们配置。  
> **异常信息：**`java.lang.OutOfMemoryError:PermGenspace`  
> 方法区溢出也是一种常见的内存溢出异常，一个类如果要被垃圾收集器回收，判定条件是很苛刻的。在经常动态生成大量Class的应用中，要特别注意这点。  
> SOF（堆栈溢出`StackOverflow`）：  
> `StackOverflowError` 的定义：当应用程序递归太深而发生堆栈溢出时，抛出该错误。  
> 因为栈一般默认为1-2m，一旦出现死循环或者是大量的递归调用，在不断的压栈过程中，造成栈容量超过1m而导致溢出。  
> **栈溢出的原因**：递归调用，大量循环或死循环，全局变量是否过多，数组、List、map数据过大。

#### 1.26.简述线程、程序、进程的基本概念。以及他们之间关系是什么? ####

> 线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。  
> 程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。  
> 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU 时间，内存空间，文件，输  
> 入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

#### 1.27.线程有哪些基本状态？这些状态是如何定义的? ####

> **新建(new)**：新创建了一个线程对象。  
> **可运行(runnable)**：线程对象创建后，其他线程(比如main线程）调用了该对象的`start()`方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu的使用权。  
> `运行(running)`：可运行状态(`runnable`)的线程获得了cpu时间片（`timeslice`），执行程序代码。  
> `阻塞(block)`：阻塞状态是指线程因为某种原因放弃了cpu使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(`runnable`)状态，才有 机会再次获得cpu timeslice转到运行(`running`)状态。  
> **阻塞的情况分三种：**  
> (一). 等待阻塞：运行(`running`)的线程执行`o.wait()`方法，JVM会把该线程放 入等待队列(waitting queue)中。  
> (二). 同步阻塞：运行(`running`)的线程在获取对象的同步锁时，若该同步锁 被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。  
> (三). 其他阻塞: 运行(running)的线程执行`Thread.sleep(long ms)或t.join()`方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当`sleep()`状态超时`join()`等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。  
> **死亡(dead)**：线程`run()、main()`方法执行结束，或者因异常退出了`run()`方法，则该线程结束生命周期。死亡的线程不可再次复生。  
> ![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16 1]

#### 1.28.Java 中 IO 流 ####

Java 中 IO 流分为几种?

> 按照流的流向分，可以分为**输入流和输出流；**  
> 按照操作单元划分，可以划分为**字节流和字符流；**  
> 按照流的角色划分为**节点流和处理流。**

Java Io 流共涉及 40 多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。  
`InputStream/Reader`: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。  
`OutputStream/Writer`: 所有输出流的基类，前者是字节输出流，后者是字符输出流。  
按操作方式分类结构图：

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16 2]

#### 1.29.java反射的作用于原理 ####

1、定义：  
反射机制是在运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意个对象，都能够调用它的任意一个方法。在java中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。

> 这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

2、哪里会用到反射机制？  
jdbc就是典型的反射

Class.forName('com.mysql.jdbc.Driver.class');//加载MySQL的驱动类

*  1

这就是反射。如hibernate，struts等框架使用反射实现的。  
3、反射的实现方式：  
第一步：获取Class对象，有4中方法：

> 1）Class.forName(“类的路径”)；  
> 2）类名.class  
> 3）对象名.getClass()  
> 4）基本类型的包装类，可以调用包装类的Type属性来获得该包装类的Class对象

4、实现Java反射的类：

> 1）**Class**：表示正在运行的Java应用程序中的类和接口  
> 注意： 所有获取对象的信息都需要Class类来实现。  
> 2）**Field**：提供有关类和接口的属性信息，以及对它的动态访问权限。  
> 3）**Constructor**：提供关于类的单个构造方法的信息以及它的访问权限  
> 4）**Method**：提供类或接口中某个方法的信息

5、反射机制的优缺点：  
优点：

> 1）能够运行时动态获取类的实例，提高灵活性；  
> 2）与动态编译结合

缺点：

> 1）使用反射性能较低，需要解析字节码，将内存中的对象进行解析。  
> 解决方案：  
> 1、通过`setAccessible(true)`关闭JDK的安全检查来提升反射速度；  
> 2、多次创建一个类的实例时，有缓存会快很多  
> 3、`ReflectASM`工具类，通过字节码生成的方式加快反射速度  
> 2）相对不安全，破坏了封装性（因为通过反射可以获得私有方法和属性）

#### 1.30.说说List,Set,Map三者的区别？ ####

> **List(对付顺序的好帮手)**： List接口存储一组不唯一（可以有多个元素引用相同的对象），有序的对象  
> **Set(注重独一无二的性质)**: 不允许重复的集合。不会有多个元素引用相同的对象。  
> **Map(用Key来搜索的专家)**: 使用键值对存储。Map会维护与Key有关联的值。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。

### 二、JVM篇 ###

#### 2.1.知识点汇总 ####

JVM是Java运行基础,面试时一定会遇到JVM的有关问题,内容相对集中,但对只是深度要求较高

超详细导图地址:[jvm思维导图][jvm]  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16 3]

#### 2.2.知识点详解： ####

> 1、**JVM内存模型：**  
> 线程独占:栈,本地方法栈,程序计数器  
> 线程共享:堆,方法区  
> 2、**栈：**  
> 又称方法栈,线程私有的,线程执行方法是都会创建一个栈阵,用来存储局部变量表,操作栈,动态链接,方法  
> 出口等信息.调用方法时执行入栈,方法返回式执行出栈.  
> 3、**本地方法栈**  
> 与栈类似,也是用来保存执行方法的信息.执行Java方法是使用栈,执行Native方法时使用本地方法栈.  
> 4、**程序计数器**  
> 保存着当前线程执行的字节码位置,每个线程工作时都有独立的计数器,只为执行Java方法服务,执行Native方法时,程序计数器为空.  
> 5、**堆**  
> JVM内存管理最大的一块,对被线程共享,目的是存放对象的实例,几乎所欲的对象实例都会放在这里,当堆没有可用空间时,会抛出OOM异常.根据对象的存活周期不同,JVM把对象进行分代管理,由垃圾回收器进行垃圾的回收管理  
> 6、**方法区：**  
> 又称非堆区,用于存储已被虚拟机加载的类信息,常量,静态变量,即时编译器优化后的代码等数据.1.7的永久代和1.8的元空间都是方法区的一种实现  
> 7、**JVM 内存可见性**  
> JMM是定义程序中变量的访问规则,线程对于变量的操作只能在自己的工作内存中进行,而不能直接对主内存操作.由于指令重排序,读写的顺序会被打乱,因此JMM需要提供原子性,可见性,有序性保证

#### 2.3.类加载与卸载 ####

加载过程:  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16 4]

> 其中**验证,准备,解析**合称链接  
> **加载**通过类的完全限定名,查找此类字节码文件,利用字节码文件创建Class对象.  
> **验证**确保Class文件符合当前虚拟机的要求,不会危害到虚拟机自身安全.  
> **准备**进行内存分配,为static修饰的类变量分配内存,并设置初始值(0或null).不包含final修饰的静态变量,因为final变量在编译时分配.  
> **解析**将常量池中的符号引用替换为直接引用的过程.直接引用为直接指向目标的指针或者相对偏移量等.  
> **初始化**主要完成静态块执行以及静态变量的赋值.先初始化父类,再初始化当前类.只有对类主动使用时才会初始化.

触发条件包括：创建类的实例时,访问类的静态方法或静态变量的时候,使用`Class.forName`反射类的时候,或者某个子类初始化的时候.  
Java自带的加载器加载的类,在虚拟机的生命周期中是不会被卸载的,只有用户自定义的加载器加载的类才可以被卸.

1、加载机制-双亲委派模式  
双亲委派模式,即加载器加载类时先把请求委托给自己的父类加载器执行,直到顶层的启动类加载器.父类加载器能够完成加载则成功返回,不能则子类加载器才自己尝试加载.  
优点:

> 1.避免类的重复加载  
> 2.避免Java的核心API被篡改

2、分代回收  
分代回收基于两个事实:大部分对象很快就不使用了,还有一部分不会立即无用,但也不会持续很长时间.  
年轻代->标记-复制  
老年代->标记-清除

3、回收算法  
a、**G1算法**  
1.9后默认的垃圾回收算法,特点保持高回收率的同时减少停顿.采用每次只清理一部分,而不是清理全部的增量式清理,以保证停顿时间不会过长  
其取消了年轻代与老年代的物理划分,但仍属于分代收集器,算法将堆分为若干个逻辑区域(region),一部分用作年轻代,一部分用作老年代,还有用来存储巨型对象的分区.  
同CMS相同,会遍历所有对象,标记引用情况,清除对象后会对区域进行复制移动,以整合碎片空间.  
**年轻代回收:**  
并行复制采用复制算法,并行收集,会StopTheWorld.  
**老年代回收:**  
会对年轻代一并回收  
初始标记完成堆root对象的标记,会StopTheWorld.  
并发标记 GC线程和应用线程并发执行.  
最终标记完成三色标记周期,会StopTheWorld.  
复制/清楚会优先对可回收空间加大的区域进行回收  
b、**ZGC算法**  
前面提供的高效垃圾回收算法,针对大堆内存设计,可以处理TB级别的堆,可以做到10ms以下的回收停顿时间

> 着色指针  
> 读屏障  
> 并发处理  
> 基于region  
> 内存压缩(整理)

**roots标记**：标记root对象,会StopTheWorld.  
**并发标记**：利用读屏障与应用线程一起运行标记,可能会发生`StopTheWorld`.  
清除会清理标记为不可用的对象.  
roots重定位：是对存活的对象进行移动,以腾出大块内存空间,减少碎片产生.重定位最开始会`StopTheWorld`,却决于重定位集与对象总活动集的比例.  
并发重定位与并发标记类似.

#### 2.4.简述一下JVM的内存模型 ####

1.JVM内存模型简介  
JVM定义了不同运行时数据区，他们是用来执行应用程序的。某些区域随着JVM启动及销毁，另外一些区域的数据是线程性独立的，随着线程创建和销毁

> 线程私有区  
> 1、**程序计数器**  
> 当同时进行的线程数超过CPU数或其内核数时，就要通过时间片轮询分派CPU的时间资源，不免发生线程切换。这时，每个线程就需要一个属于自己的计数器来记录下一条要运行的指令。如果执行的是JAVA方法，计数器记录正在执行的java字节码地址，如果执行的是`native`方法，则计数器为空。  
> 2、**虚拟机栈**  
> 线程私有的，与线程在同一时间创建。管理JAVA方法执行的内存模型。每个方法执行时都会创建一个桢栈来存储方法的的变量表、操作数栈、动态链接方法、返回值、返回地址等信息。栈的大小决定了方法调用的可达深度（递归多少层次，或嵌套调用多少层其他方法，-Xss参数可以设置虚拟机栈大小）。栈  
> 的大小可以是固定的，或者是动态扩展的。如果请求的栈深度大于最大可用深度，则抛出`stackOverflowError`；如果栈是可动态扩展的，但没有内存空间支持扩展，则抛出`OutofMemoryError`。  
> 3、**本地方法栈**  
> 与虚拟机栈作用相似。但它不是为Java方法服务的，而是本地方法（C语言）。由于规范对这块没有强制要求，不同虚拟机实现方法不同。

**线程共享区**

> 1、方法区  
> 线程共享的，用于存放被虚拟机加载的类的元数据信息，如常量、静态变量和即时编译器编译后的代码。若要分代，算是永久代（老年代），以前类大多“static”的，很少被卸载或收集，现回收废弃常量和无用的类。其中运行时常量池存放编译生成的各种常量。（如果hotspot虚拟机确定一个类的定义信息  
> 不会被使用，也会将其回收。回收的基本条件至少有：所有该类的实例被回收，而且装载该类的ClassLoader被回收）  
> 2、堆  
> 存放对象实例和数组，是垃圾回收的主要区域，分为新生代和老年代。刚创建的对象在新生代的Eden区中，经过GC后进入新生代的S0区中，再经过GC进入新生代的S1区中，15次GC后仍存在就进入老年代。这是按照一种回收机制进行划分的，不是固定的。若堆的空间不够实例分配，则`OutOfMemoryError`。

#### 2.5.堆和栈的区别 ####

栈是运行时单位，代表着逻辑，内含基本数据类型和堆中对象引用，所在区域连续，没有碎片；堆是存储单位，代表着数据，可被多个栈共享（包括成员中基本数据类型、引用和引用对象），所在区域不连续，会有碎片。

> 1、**功能不同**  
> 栈内存用来存储局部变量和方法调用，而堆内存用来存储Java中的对象。无论是成员变量，局部变量，还是类变量，它们指向的对象都存储在堆内存中。  
> 2、**共享性不同**  
> 栈内存是线程私有的。  
> 堆内存是所有线程共有的。  
> 3、**异常错误不同**  
> 如果栈内存或者堆内存不足都会抛出异常。  
> 栈空间不足：`java.lang.StackOverFlowError`。  
> 堆空间不足：`java.lang.OutOfMemoryError`。  
> 4、**空间大小**  
> 栈的空间大小远远小于堆的

#### 2.6.什么时候会触发FullGC ####

除直接调用`System.gc`外，触发Full GC执行的情况有如下四种。

> 1.**旧生代空间不足**  
> 旧生代空间只有在新生代对象转入及创建为大对象、大数组时才会出现不足的现象，当执行Full GC后空间仍然不足，则抛出如下错误：`java.lang.OutOfMemoryError: Java heap space`为避免以上两种状况引起的FullGC，调优时应尽量做到让对象在Minor GC阶段被回收、让对象在新生代多存活一段时间及不要创建过大的对象及数组。  
> 2.**Permanet Generation空间满**  
> `PermanetGeneration`中存放的为一些class的信息等，当系统中要加载的类、反射的类和调用的方法较多时，Permanet Generation可能会被占满，在未配置为采用CMS GC的情况下会执行Full GC。如果经过Full GC仍然回收不了，那么JVM会抛出如下错误信息：`java.lang.OutOfMemoryError: PermGen space`  
> 为避免Perm Gen占满造成Full GC现象，可采用的方法为增大Perm Gen空间或转为使用CMS GC。  
> 3.**CMS GC时出现promotion failed和concurrent mode failure**  
> 对于采用CMS进行旧生代GC的程序而言，尤其要注意GC日志中是否有`promotion failed和concurrent mode failure`两种状况，当这两种状况出现时可能会触发Full GC。promotionfailed是在进行Minor GC时，survivor space放不下、对象只能放入旧生代，而此时旧生代也放不下造成的；concurrent mode failure是在执行CMS GC的过程中同时有对象要放入旧生代，而此时旧生代空间不足造成的。  
> **应对措施为**：**增大survivorspace、旧生代空间或调低触发并发GC的比率，但在JDK 5.0+、6.0+的版本中有可能会由于JDK的bug29导致CMS在remark完毕后很久才触发sweeping动作**。对于这种状况，可通过设置-XX:CMSMaxAbortablePrecleanTime=5（单位为ms）来避免。  
> 4.**统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间**  
> 这是一个较为复杂的触发情况，Hotspot为了避免由于新生代对象晋升到旧生代导致旧生代空间不足的现象，在进行Minor GC时，做了一个判断，如果之前统计所得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间，那么就直接触发Full GC。  
> 例如程序第一次触发MinorGC后，有6MB的对象晋升到旧生代，那么当下一次Minor GC发生时，首先检查旧生代的剩余空间是否大于6MB，如果小于6MB，则执行Full GC。  
> 当新生代采用PSGC时，方式稍有不同，PS GC是在Minor GC后也会检查，例如上面的例子中第一次Minor GC后，PS GC会检查此时旧生代的剩余空间是否大于6MB，如小于，则触发对旧生代的回收。  
> 除了以上4种状况外，对于使用RMI来进行RPC或管理的Sun JDK应用而言，默认情况下会一小时执行一次Full GC。可通过在启动时通过`- java Dsun.rmi.dgc.client.gcInterval=3600000`来设置Full GC执行的间隔时间或通过`-XX:+ DisableExplicitGC`来禁止RMI调用`System.gc`。

#### 2.7.什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？ ####

Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。 Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。

#### 2.8.Java内存结构 ####

方法区和对是所有线程共享的内存区域；而java栈、本地方法栈和程序员计数器是运行是线程私有的内存区域。

> **Java堆（Heap）**,是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。  
> **方法区（Method Area）**,方法区（Method Area）与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。  
> **程序计数器（Program Counter Register）**,程序计数器（Program Counter Register）是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的行号指示器。  
> **JVM栈（JVM Stacks）**,与程序计数器一样，Java虚拟机栈（Java Virtual Machine Stacks）也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。  
> **本地方法栈（Native Method Stacks）**,本地方法栈（Native Method Stacks）与虚拟机栈所发挥的作用是非常相似的，其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则是为虚拟机使用到的Native方法服务。

#### 2.9.对象分配规则 ####

> 对象优先分配在Eden区，如果Eden区没有足够的空间时，虚拟机执行一次Minor GC。  
> 大对象直接进入老年代（大对象是指需要大量连续内存空间的对象）。这样做的目的是避免在Eden区和两个Survivor区之间发生大量的内存拷贝（新生代采用复制算法收集内存）。  
> 长期存活的对象进入老年代。虚拟机为每个对象定义了一个年龄计数器，如果对象经过了1次Minor GC那么对象会进入Survivor区，之后每经过一次Minor GC那么对象的年龄加1，知道达到阀值对象进入老年区。  
> 动态判断对象的年龄。如果Survivor区中相同年龄的所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象可以直接进入老年代。  
> 空间分配担保。每次进行Minor GC时，JVM会计算Survivor区移至老年区的对象的平均大小，如果这个值大于老年区的剩余值大小则进行一次Full GC，如果小于检查HandlePromotionFailure设置，如果true则只进行Monitor GC,如果false则进行Full GC。

#### 2.10.Java对象创建过程 ####

> 1.JVM遇到一条新建对象的指令时首先去检查这个指令的参数是否能在常量池中定义到一个类的符号引用。然后加载这个类（类加载过程在后边讲）  
> 2.为对象分配内存。一种办法“指针碰撞”、一种办法“空闲列表”，最终常用的办法“本地线程缓冲分配(TLAB)”  
> 3.将除对象头外的对象内存空间初始化为0  
> 4.对对象头进行必要设置

#### 2.11.类的生命周期 ####

类的生命周期包括这几个部分，**加载、连接、初始化、使用和卸载**，其中前三部是类的加载的过程加载，查找并加载类的二进制数据，在Java堆中也创建一个`java.lang.Class`类的对象连接，连接又包含三块内容：**验证、准备、初始化。**

> 1）验证，文件格式、元数据、字节码、符号  
> 引用验证；  
> 2）准备，为类的静态变量分配内存，并将其初始化为默认值；  
> 3）解析，把类中的符号引用转换为直接引用初始化，为类的静态变量赋予正确的初始值使用，new出对象程序中使用卸载，执行垃圾回收

#### 2.12.简述Java的对象结构 ####

Java对象由三个部分组成：对象头、实例数据、对齐填充。  
对象头由两部分组成，第一部分存储对象自身的运行时数据：哈希码、GC分代年龄、锁标识状态、线程持有的锁、偏向线程ID（一般占32/64 bit）。第二部分是指针类型，指向对象的类元数据类型（即对象代表哪个类）。如果是数组对象，则对象头中还有一部分用来记录数组长度。  
实例数据用来存储对象真正的有效信息（包括父类继承下来的和自己定义的）  
对齐填充：JVM要求对象起始地址必须是8字节的整数倍（8字节对齐）

#### 2.13.如何判断对象可以被回收？ ####

判断对象是否存活一般有两种方式：

> **引用计数**：每个对象有一个引用计数属性，新增一个引用时计数加1，引用释放时计数减1，计数为0时可以回收。此方法简单，无法解决对象相互循环引用的问题。  
> **可达性分析（Reachability Analysis）**：从GC Roots开始向下搜索，搜索所走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的，不可达对象。

#### 2.14.JVM的永久代中会发生垃圾回收么？ ####

垃圾回收不会发生在永久代，如果永久代满了或者是超过了临界值，会触发完全垃圾回收(Full GC)。如果你仔细查看垃圾收集器的输出信息，就会发现永久代也是被回收的。这就是为什么正确的永久代大小对避免Full GC是非常重要的原因。请参考下Java8：从永久代到元数据区 (注：Java8中已经移除了永久代，新加了一个叫做元数据区的native内存区)

#### 2.15.垃圾收集算法 ####

GC最基础的算法有三种： 标记 -清除算法、复制算法、标记-压缩算法，我们常用的垃圾回收器一般都采用分代收集算法。

> **标记 -清除算法**，“标记-清除”（Mark-Sweep）算法，如它的名字一样，算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记完成后统一回收掉所有被标记的对象。  
> **复制算法**，“复制”（Copying）的收集算法，它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。  
> **标记-压缩算法**，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存  
> **分代收集算法**，“分代收集”（Generational Collection）算法，把Java堆分为新生代和老年代，这样就可以根据各个年代的特点采用最适当的收集算法。

#### 2.16.调优命令有哪些？ ####

详情查看此文:[jvm调优][jvm 1]  
Sun JDK监控和故障处理命令有`jps jstat jmap jhat jstack jinfo`

> **jps，JVM Process Status Tool**,显示指定系统内所有的HotSpot虚拟机进程。  
> **jstat，JVM statistics Monitoring**是用于监视虚拟机运行时状态信息的命令，它可以显示出虚拟机进程中的类装载、内存、垃圾收集、JIT编译等运行数据。  
> **jmap**，JVM Memory Map命令用于生成heap dump文件  
> **jhat**，JVM Heap Analysis Tool命令是与jmap搭配使用，用来分析jmap生成的dump，jhat内置了一个微型的HTTP/HTML服务器，生成dump的分析结果后，可以在浏览器中查看  
> **jstack**，用于生成java虚拟机当前时刻的线程快照。  
> **jinfo**，`JVM Configuration info` 这个命令作用是实时查看和调整虚拟机运行参数。

#### 2.17.调优工具 ####

常用调优工具分为两类,jdk自带监控工具：jconsole和jvisualvm，第三方有：MAT(Memory Analyzer Tool)、GChisto。

> `jconsole`，Java Monitoring and Management Console是从java5开始，在JDK中自带的java监控和管理控制台，用于对JVM中内存，线程和类等的监控  
> `jvisualvm`，jdk自带全能工具，可以分析内存快照、线程快照；监控内存变化、GC变化等。  
> `MAT`，Memory Analyzer Tool，一个基于Eclipse的内存分析工具，是一个快速、功能丰富的Java heap分析工具，它可以帮助我们查找内存泄漏和减少内存消耗  
> `GChisto`，一款专业分析gc日志的工具

#### 2.18.Minor GC与Full GC分别在什么时候发生？ ####

新生代内存不够用时候发生MGC也叫YGC，JVM内存不够的时候发生FGC

#### 2.19.你知道哪些JVM性能调优 ####

**设定堆内存大小**

-Xmx：堆内存最大限制。

*  1
 *  2

**设定新生代大小**。 新生代不宜太小，否则会有大量对象涌入老年代

-XX:NewSize：新生代大小
    -XX:NewRatio 新生代和老生代占比
    -XX:SurvivorRatio：伊甸园空间和幸存者空间的占比

*  1
 *  2
 *  3

**设定垃圾回收器** 年轻代用 -XX:+UseParNewGC 年老代用-`XX:+UseConcMarkSweepGC`

#### 2.20.简述Java垃圾回收机制? ####

在Java中，程序员是不需要显示的去释放一个对象的内存的，而是由虚拟机自行执行。在JVM中，有一个垃圾回收线程，它是低优先级的，在正常情况下是不会执行的，只有在虚拟机空闲或者当前堆内存不足时，才会触发执行，扫面那些没有被任何引用的对象，并将它们添加到要回收的集合中，进行回收

#### **篇幅限制下面就只能给大家展示小册部分内容了，需要完整版的小伙伴点赞+收藏，关注在，【下方点击名片】即可免费获取** ####

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/d0cf0b5ee77846e99dd331be3e0a7902.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA55m95aSn6ZSF,size_20,color_FFFFFF,t_70,g_se,x_16
[Link 1]: https://so.csdn.net/so/search?q=%E8%80%A6%E5%90%88%E5%BA%A6&spm=1001.2101.3001.7020
[Link 2]: https://so.csdn.net/so/search?q=%E9%9D%A2%E5%90%91%E8%BF%87%E7%A8%8B&spm=1001.2101.3001.7020
[Link 3]: https://so.csdn.net/so/search?q=%E5%B5%8C%E5%85%A5%E5%BC%8F%E5%BC%80%E5%8F%91&spm=1001.2101.3001.7020
[c511b28b433643914eb81fe9985d52a0.png]: https://img-blog.csdnimg.cn/img_convert/c511b28b433643914eb81fe9985d52a0.png
[70ad83bfc59fc217af5b8d0bea7e9ae8.png]: https://img-blog.csdnimg.cn/img_convert/70ad83bfc59fc217af5b8d0bea7e9ae8.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/38b3d93af9f04f1fb09535d4c4d24615.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA55m95aSn6ZSF,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/70b41de97ffc43f9bbd46e9da4358521.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA55m95aSn6ZSF,size_20,color_FFFFFF,t_70,g_se,x_16
[jvm]: https://www.processon.com/view/link/5eea141cf346fb1ae56a44e7
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/1812741509b1471a9c2a64073f57535e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA55m95aSn6ZSF,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA55m95aSn6ZSF_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/9bb5e9a484f444ce80748ff1e9096074.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA55m95aSn6ZSF,size_20,color_FFFFFF,t_70,g_se,x_16
[jvm 1]: https://baidaguo.blog.csdn.net/article/details/121397268?spm=1001.2014.3001.5502