110道Java初级面试题及答案（最新Java初级面试题大汇总）

史上最全Java初中级面试题，发现网上很多Java初级面试题都没有答案，所以花了很长时间搜集整理出来了这套Java面试题大全，希望对大家有帮助哈~

本人发现网上虽然有不少Java相关的面试题，但第一未必全，第二未必有答案，第三虽然有答案，但未必能在面试中说，所以在本文里，会不断收集各种面试题，并站在面试官的立场上，给出我自己的答案。

如果不背 Java面试题的答案，肯定面试会挂！

这套Java面试题大全，希望对大家有帮助哈~

博主已将以下这些面试题整理成了一个Java面试手册，是PDF版的

1、为什么使用Executor框架？

**1、**每次执行任务创建线程 new Thread()比较消耗性能，创建一个线程是比较耗时、耗资源的。

**2、**调用 new Thread()创建的线程缺乏管理，被称为野线程，而且可以无限制的创建，线程之间的相互竞争会导致过多占用系统资源而导致系统瘫痪，还有线程之间的频繁交替也会消耗很多系统资源。

**3、**接使用new Thread() 启动的线程不利于扩展，比如定时执行、定期执行、定时定期执行、线程中断等都不便实现。

2、你能保证 GC 执行吗？

不能，虽然你可以调用 System.gc() 或者 Runtime.gc()，但是没有办法保证 GC的执行。

3、UML中有哪些常用的图？

UML定义了多种图形化的符号来描述软件系统部分或全部的静态结构和动态结构，包括：用例图（use case diagram）、类图（class diagram）、时序图（sequence diagram）、协作图（collaboration diagram）、状态图（statechart diagram）、活动图（activity diagram）、构件图（component diagram）、部署图（deployment diagram）等。在这些图形化符号中，有三种图最为重要，分别是：用例图（用来捕获需求，描述系统的功能，通过该图可以迅速的了解系统的功能模块及其关系）、类图（描述类以及类与类之间的关系，通过该图可以快速了解系统）、时序图（描述执行特定任务时对象之间的交互关系以及执行顺序，通过该图可以了解对象能接收的消息也就是说对象能够向外界提供的服务）。

用例图：

类图：

时序图：

4、volatile关键字的原理是什么？干什么用的？

使用了volatile关键字的变量，每当变量的值有变动的时候，都会将更改立即同步到主内存中；而如果某个线程想要使用这个变量，就先要从主存中刷新到工作内存，这样就确保了变量的可见性。

一般使用一个volatile修饰的bool变量，来控制线程的运行状态。

volatile boolean stop = false; void stop(){ this.stop = true; } void start(){ new Thread(()->{ while (!stop){ //sth } }).start(); }

5、synchronized 和 Lock 有什么区别？

**1、**首先synchronized是Java内置关键字，在JVM层面，Lock是个Java类；

**2、**synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。

**3、**synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁；而 lock 需要自己加锁和释放锁，如果使用不当没有 unLock()去释放锁就会造成死锁。

**4、**通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

6、抽象类必须要有抽象方法吗

不是必须。抽象类可以没有抽象方法。

7、强引用、软引用、弱引用、虚引用是什么，有什么区别？

**1、**强引用，就是普通的对象引用关系，如 String s = new String(“ConstXiong”)

**2、**软引用，用于维护一些可有可无的对象。只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。SoftReference 实现

**3、**弱引用，相比软引用来说，要更加无用一些，它拥有更短的生命周期，当 JVM 进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。WeakReference 实现

**4、**虚引用是一种形同虚设的引用，在现实场景中用的不是很多，它主要用来跟踪对象被垃圾回收的活动。PhantomReference 实现

8、Servlet的生命周期？

**1、**加载：判断servlet实例是否存在，如果不存在，就加载serlvet

**2、**实例化：

**3、**初始化

4、服务

5、销毁

9、Hibernate的对象有几种状态

**1、**瞬时态（transient）

**2、**持久态（persistent）

**3、**游离态（detached）

10、说一下HashMap的实现原理？

**1、**HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

**2、**HashMap的数据结构： 在Java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

HashMap 基于 Hash 算法实现的

**1、**当我们往HashMap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标

**2、**存储时，如果出现hash值相同的key，此时有两种情况。

(1)如果key相同，则覆盖原始值；

(2)如果key不同（出现冲突），则将当前的key-value放入链表中

**3、**获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。

**4、**理解了以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。

需要注意Jdk 1.8中对HashMap的实现做了优化，当链表中的节点数据超过八个之后，该链表会转为红黑树来提高查询效率，从原来的O(n)到O(logn)

1、java中有几种方法可以实现一个线程？

继承 Thread 类

实现 Runnable 接口

实现 Callable 接口，需要实现的是 call() 方法

2、Java 中的 HashSet，内部是如何工作的？

HashSet 的内部采用 HashMap来实现。由于 Map 需要 key 和 value，所以所有 key 的都有一个默认 value。类似于 HashMap，HashSet 不允许重复的 key，只允许有一个null key，意思就是 HashSet 中只允许存储一个 null 对象。

3、redux的工作流程?

首先，我们看下几个核心概念：

**1、**Store：保存数据的地方，你可以把它看成一个容器，整个应用只能有一个Store。

**2、**State：Store对象包含所有数据，如果想得到某个时点的数据，就要对Store生成快照，这种时点的数据集合，就叫做State。

**3、**Action：State的变化，会导致View的变化。但是，用户接触不到State，只能接触到View。所以，State的变化必须是View导致的。Action就是View发出的通知，表示State应该要发生变化了。

**4、**Action Creator：View要发送多少种消息，就会有多少种Action。如果都手写，会很麻烦，所以我们定义一个函数来生成Action，这个函数就叫Action Creator。

**5、**Reducer：Store收到Action以后，必须给出一个新的State，这样View才会发生变化。这种State的计算过程就叫做Reducer。Reducer是一个函数，它接受Action和当前State作为参数，返回一个新的State。

**6、**dispatch：是View发出Action的唯一方法。

然后我们过下整个工作流程：

**1、**首先，用户（通过View）发出Action，发出方式就用到了dispatch方法。

**2、**然后，Store自动调用Reducer，并且传入两个参数：当前State和收到的Action，Reducer会返回新的State

**3、**State一旦有变化，Store就会调用监听函数，来更新View。

到这儿为止，一次用户交互流程结束。可以看到，在整个流程中数据都是单向流动的，这种方式保证了流程的清晰。

redux原理详解

4、String类的常用方法有那些？

**1、**charAt：返回指定索引处的字符

**2、**indexOf()：返回指定字符的索引

**3、**replace()：字符串替换

**4、**trim()：去除字符串两端空白

**5、**split()：分割字符串，返回一个分割后的字符串数组

**6、**getBytes()：返回字符串的byte类型数组

**7、**length()：返回字符串长度

**8、**toLowerCase()：将字符串转成小写字母

**9、**toUpperCase()：将字符串转成大写字符

**10、**substring()：截取字符串

**11、**format()：格式化字符串

**12、**equals()：字符串比较

5、请你谈谈对OOM的认识

OOM是非常严重的问题，除了程序计数器，其他内存区域都有溢出的风险。和我们平常工作最密切的，就是堆溢出。另外，元空间在方法区内容非常多的情况下也会溢出。还有就是栈溢出，这个通常影响比较小。堆外也有溢出的可能，这个就比较难排查一些。

6、ParNew 垃圾收集器（Serial+多线程）

ParNew 垃圾收集器其实是 Serial 收集器的多线程版本，也使用复制算法，除了使用多线程进行垃圾收集之外，其余的行为和 Serial 收集器完全一样， ParNew 垃圾收集器在垃圾收集过程中同样也要暂停所有其他的工作线程。

ParNew 收集器默认开启和 CPU 数目相同的线程数，可以通过-XX:ParallelGCThreads 参数来限制垃圾收集器的线程数。【Parallel：平行的】

ParNew 虽然是除了多线程外和Serial 收集器几乎完全一样，但是ParNew垃圾收集器是很多 java虚拟机运行在 Server 模式下新生代的默认垃圾收集器。

7、Java 中如何格式化一个日期？如格式化为 ddMMyyyy 的形式？

http://javarevisited.blogspot.com/2011/09/convert-date-to-string-simpledateformat.html

Java 中，可以使用 SimpleDateFormat 类或者 joda-time 库来格式日期。DateFormat 类允许你使用多种流行的格式来格式化日期。参见中的示例代码，代码中演示了将日期格式化成不同的格式，如 dd-MM-yyyy 或 ddMMyyyy。

8、什么是Java虚拟机

任何一种可以运行Java字节码的软件均可看成是Java的虚拟机（JVM）

9、Java 中的同步集合与并发集合有什么区别？

同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。在 Java1.5 之前程序员们只有同步集合来用且在多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5 介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。

10、适配器模式和代理模式之前有什么不同？

这个问题与前面的类似，适配器模式和代理模式的区别在于他们的意图不同。由于适配器模式和代理模式都是封装真正执行动作的类，因此结构是一致的，但是适配器模式用于接口之间的转换，而代理模式则是增加一个额外的中间层，以便支持分配、控制或智能访问。

1、说说G1垃圾收集器的工作原理

优点：指定最大停顿时间、分Region的内存布局、按收益动态确定回收集

**1、**G1开创的基于Region的堆内存布局是它能够实现这个目标的关键。虽然G1也仍是遵循分代收集理论设计的，但其堆内存的布局与其他收集器有非常明显的差异：G1不再坚持固定大小以及固定数量的分代区域划分，而是把连续的Java堆划分为多个大小相等的独立区域（Region），每一个Region都可以根据需要，扮演新生代的Eden空间、Survivor空间，或者老年代空间。收集器能够对扮演不同角色的Region采用不同的策略去处理，这样无论是新创建的对象还是已经存活了一段时间、熬过多次收集的旧对象都能获取很好的收集效果。

**2、**虽然G1仍然保留新生代和老年代的概念，但新生代和老年代不再是固定的了，它们都是一系列区域（不需要连续）的动态集合。G1收集器之所以能建立可预测的停顿时间模型，是因为它将Region作为单次回收的最小单元，即每次收集到的内存空间都是Region大小的整数倍，这样可以有计划地避免在整个Java堆中进行全区域的垃圾收集。更具体的处理思路是让G1收集器去跟踪各个Region里面的垃圾堆积的“价值”大小，价值即回收所获得的空间大小以及回收所需时间的经验值，然后在后台维护一个优先级列表，每次根据用户设定允许的收集停顿时间（使用参数-XX：MaxGCPauseMillis指定，默认值是200毫秒），优先处理回收价值收益最大的那些Region，这也就是“Garbage First”名字的由来。这种使用Region划分内存空间，以及具有优先级的区域回收方式，保证了G1收集器在有限的时间内获取尽可能高的收集效率。

**3、**G1收集器的运作过程大致可划分为以下四个步骤：·初始标记 （Initial Marking）：仅仅只是标记一下GC Roots能直接关联到的对象，并且修改TAMS指针的值，让下一阶段用户线程并发运行时，能正确地在可用的Region中分配新对象。这个阶段需要停顿线程，但耗时很短，而且是借用进行Minor GC的时候同步完成的，所以G1收集器在这个阶段实际并没有额外的停顿。·并发标记 （Concurrent Marking）：从GC Root开始对堆中对象进行可达性分析，递归扫描整个堆里的对象图，找出要回收的对象，这阶段耗时较长，但可与用户程序并发执行。当对象图扫描完成以后，还要重新处理SATB记录下的在并发时有引用变动的对象。·最终标记 （Final Marking）：对用户线程做另一个短暂的暂停，用于处理并发阶段结束后仍遗留下来的最后那少量的SATB记录。·筛选回收 （Live Data Counting and Evacuation）：负责更新Region的统计数据，对各个Region的回收价值和成本进行排序，根据用户所期望的停顿时间来制定回收计划，可以自由选择任意多个Region构成回收集，然后把决定回收的那一部分Region的存活对象复制到空的Region中，再清理掉整个旧Region的全部空间。这里的操作涉及存活对象的移动，是必须暂停用户线程，由多条收集器线程并行完成的。从上述阶段的描述可以看出，G1收集器除了并发标记外，其余阶段也是要完全暂停用户线程的 。

2、JRE、JDK、JVM 及 JIT 之间有什么不同？

JRE 代表 Java 运行时（Java run-time），是运行 Java 引用所必须的。JDK 代表 Java 开发工具（Java development kit），是 Java 程序的开发工具，如 Java编译器，它也包含 JRE。JVM 代表 Java 虚拟机（Java virtual machine），它的责任是运行 Java 应用。JIT 代表即时编译（Just In Time compilation），当代码执行的次数超过一定的阈值时，会将 Java 字节码转换为本地代码，如，主要的热点代码会被准换为本地代码，这样有利大幅度提高 Java 应用的性能。

3、当父类引用指向子类对象的时候，子类重写了父类方法和属性，那么当访问属性的时候，访问是谁的属性？调用方法时，调用的是谁的方法？

子类重写了父类方法和属性，访问的是父类的属性，调用的是子类的方法

4、堆溢出的原因？

堆用于存储对象实例，只要不断创建对象并保证 GC Roots 到对象有可达路径避免垃圾回收，随着对象数量的增加，总容量触及最大堆容量后就会 OOM，例如在 while 死循环中一直 new 创建实例。

堆 OOM 是实际应用中最常见的 OOM，处理方法是通过内存映像分析工具对 Dump 出的堆转储快照分析，确认内存中导致 OOM 的对象是否必要，分清到底是内存泄漏还是内存溢出。

如果是内存泄漏，通过工具查看泄漏对象到 GC Roots 的引用链，找到泄露对象是通过怎样的引用路径、与哪些 GC Roots 关联才导致无法回收，一般可以准确定位到产生内存泄漏代码的具***置。

如果不是内存泄漏，即内存中对象都必须存活，应当检查 JVM 堆参数，与机器内存相比是否还有向上调整的空间。再从代码检查是否存在某些对象生命周期过长、持有状态时间过长、存储结构设计不合理等情况，尽量减少程序运行期的内存消耗。

5、说一下 runnable 和 callable 有什么区别

相同点：

**1、**都是接口

**2、**都可以编写多线程程序

**3、**都采用Thread.start()启动线程

主要区别：

Runnable 接口 run 方法无返回值；Callable 接口 call 方法有返回值，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果

Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出异常，可以获取异常信息 注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

6、JVM 类加载机制

JVM 类加载机制分为五个部分：加载，验证，准备，解析，初始化。

加载

加载是类加载过程中的一个阶段， 这个阶段会在内存中生成一个代表这个类的 java.lang.Class 对象， 作为方法区这个类的各种数据的入口。注意这里不一定非得要从一个 Class 文件获取，这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）。

验证

这一阶段的主要目的是为了确保 Class 文件的字节流中包含的信息是否符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

准备

准备阶段是正式为类变量分配内存并设置类变量的初始值阶段，即在方法区中分配这些变量所使用的内存空间。注意这里所说的初始值概念，比如一个类变量定义为：

实际上变量 v 在准备阶段过后的初始值为 0 而不是 8080， 将 v 赋值为 8080 的 put static 指令是程序被编译后， 存放于类构造器方法之中。

但是注意如果声明为：

public static final int v = 8080;

在编译阶段会为 v 生成 ConstantValue 属性，在准备阶段虚拟机会根据 ConstantValue 属性将 v赋值为 8080。

解析

解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是 class 文件中的

public static int v = 8080;

实际上变量 v 在准备阶段过后的初始值为 0 而不是 8080， 将 v 赋值为 8080 的 put static 指令是程序被编译后， 存放于类构造器方法之中。但是注意如果声明为：

在编译阶段会为 v 生成 ConstantValue 属性，在准备阶段虚拟机会根据 ConstantValue 属性将 v赋值为 8080。

解析

解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是 class 文件中的

public static final int v = 8080;

在编译阶段会为 v 生成 ConstantValue 属性，在准备阶段虚拟机会根据 ConstantValue 属性将 v赋值为 8080。

解析

解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是 class 文件中的：

**1、**CONSTANT_Class_info

**2、**CONSTANT_Field_info

**3、**CONSTANT_Method_info

等类型的常量。

符号引用

符号引用与虚拟机实现的布局无关， 引用的目标并不一定要已经加载到内存中。各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须是一致的，因为符号引用的字面量形式明确定义在 Java 虚拟机规范的 Class 文件格式中。

直接引用

直接引用可以是指向目标的指针，相对偏移量或是一个能间接定位到目标的句柄。如果有了直接引用，那引用的目标必定已经在内存中存在。

初始化

初始化阶段是类加载最后一个阶段，前面的类加载阶段之后，除了在加载阶段可以自定义类加载器以外，其它操作都由 JVM 主导。到了初始阶段，才开始真正执行类中定义的 Java 程序代码。

类构造器

初始化阶段是执行类构造器方法的过程。方法是由编译器自动收集类中的类变量的赋值操作和静态语句块中的语句合并而成的。虚拟机会保证子方法执行之前，父类的方法已经执行完毕， 如果一个类中没有对静态变量赋值也没有静态语句块，那么编译器可以不为这个类生成()方法。

注意以下几种情况不会执行类初始化：

**1、**通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化。

**2、**定义对象数组，不会触发该类的初始化。

**3、**常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触发定义常量所在的类。

**4、**通过类名获取 Class 对象，不会触发类的初始化。

**5、**通过 Class.forName 加载指定类时，如果指定参数 initialize 为 false 时，也不会触发类初始化，其实这个参数是告诉虚拟机，是否要对类进行初始化。

**6、**通过 ClassLoader 默认的 loadClass 方法，也不会触发初始化动作。

7、怎么打破双亲委派模型？

打破双亲委派机制则不仅要继承ClassLoader类，还要重写loadClass和findClass方法。

8、垃圾收集算法

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

标记 -清除算法

“标记-清除”（Mark-Sweep）算法，如它的名字一样，算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记完成后统一回收掉所有被标记的对象。

复制算法

“复制”（Copying）的收集算法，它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。

标记-压缩算法

标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存

分代收集算法

“分代收集”（Generational Collection）算法，把Java堆分为新生代和老年代，这样就可以根据各个年代的特点采用最适当的收集算法

9、你有哪些手段来排查 OOM 的问题？

**1、**增加两个参数 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heapdump.hprof，当 OOM 发生时自动 dump 堆内存信息到指定目录

**2、**同时 jstat 查看监控 JVM 的内存和 GC 情况，先观察问题大概出在什么区域

**3、**使用 MAT 工具载入到 dump 文件，分析大对象的占用情况，比如 HashMap 做缓存未清理，时间长了就会内存溢出，可以把改为弱引用

10、假设把实例化的数组的变量当成方法参数，当方法执行的时候改变了数组内的元素，那么在方法外，数组元素有发生改变吗？

改变了，因为传递是对象的引用，操作的是引用所指向的对象

1、怎么获取 Java 程序使用的内存？堆使用的百分比？

可以通过 java.lang.Runtime 类中与内存相关方法来获取剩余的内存，总内存及最大堆内存。通过这些方法你也可以获取到堆使用的百分比及堆内存的剩余空间。Runtime.freeMemory() 方法返回剩余空间的字节数，Runtime.totalMemory() 方法总内存的字节数，Runtime.maxMemory() 返回最大内存的字节数。

2、强引用、软引用、弱引用、虚引用是什么？

普通的对象引用关系就是强引用

软引用用于维护一些可有可无的对象。只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。

弱引用对象相比较软引用，要更加无用一些，它拥有更短的生命周期。当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。

虚引用是一种形同虚设的引用，在现实场景中用的不是很多，它主要用来跟踪对象被垃圾回收的活动。

3、G1 收集器

Garbage first 垃圾收集器是目前垃圾收集器理论发展的最前沿成果，相比与 CMS 收集器， G1 收集器两个最突出的改进是：

**1、**基于标记-整理算法，不产生内存碎片。

**2、**可以非常精确控制停顿时间，在不牺牲吞吐量前提下，实现低停顿垃圾回收。G1 收集器避免全区域垃圾收集，它把堆内存划分为大小固定的几个独立区域，并且跟踪这些区域的垃圾收集进度，同时在后台维护一个优先级列表，每次根据所允许的收集时间， 优先回收垃圾最多的区域。区域划分和优先级区域回收机制，确保 G1 收集器可以在有限时间获得最高的垃圾收集效率

4、运行时常量池溢出的原因？

String 的intern方法是一个本地方法，作用是如果字符串常量池中已包含一个等于此 String 对象的字符串，则返回池中这个字符串的 String 对象的引用，否则将此 String 对象包含的字符串添加到常量池并返回此 String 对象的引用。

在 JDK6 及之前常量池分配在永久代，因此可以通过-XX:PermSize和-XX:MaxPermSize限制永久代大小，间接限制常量池。在 while 死循环中调用intern方法导致运行时常量池溢出。在 JDK7 后不会出现该问题，因为存放在永久代的字符串常量池已经被移至堆中。

5、Java最顶级的父类是哪个？

Object

6、JVM 监控与分析工具你用过哪些？介绍一下。

**1、**jps，显示系统所有虚拟机进程信息的命令行工具

**2、**jstat，监视分析虚拟机运行状态的命令行工具

**3、**jinfo，查看和调整虚拟机参数的命令行工具

**4、**jmap，生成虚拟机堆内存转储快照的命令行工具

**5、**jhat，显示和分析虚拟机的转储快照文件的命令行工具

**6、**jstack，生成虚拟机的线程快照的命令行工具

**7、**jcmd，虚拟机诊断工具，JDK 7 提供

**8、**jhsdb，基于服务性代理实现的进程外可视化调试工具，JDK 9 提供

**9、**JConsole，基于JMX的可视化监视和管理工具

**10、**jvisualvm，图形化虚拟机使用情况的分析工具

**11、**Java Mission Control，监控和管理 Java 应用程序的工具

**1、**MAT，Memory Analyzer Tool，虚拟机内存分析工具

**2、**vjtools，唯品会的包含核心类库与问题分析工具

**3、**arthas，阿里开源的 Java 诊断工具

**4、**greys，JVM进程执行过程中的异常诊断工具

**5、**GCHisto，GC 分析工具

**6、**GCViewer，GC 日志文件分析工具

**7、**GCeasy，在线版 GC 日志文件分析工具

**8、**JProfiler，检查、监控、追踪 Java 性能的工具

**9、**BTrace，基于动态字节码修改技术(Hotswap)实现的Java程序追踪与分析工具

下面可以重点体验下：

JDK 自带的命令行工具方便快捷，不是特别复杂的问题可以快速定位；

阿里的 arthas 命令行也不错；

可视化工具 MAT、JProfiler 比较强大。

7、JVM新生代中为什么要分为Eden和Survivor？

如果没有Survivor，Eden区每进行一次Minor GC，存活的对象就会被送到老年代。老年代很快被填满，触发Major GC.老年代的内存空间远大于新生代，进行一次Full GC消耗的时间比Minor GC长得多,所以需要分为Eden和Survivor。Survivor的存在意义，就是减少被送到老年代的对象，进而减少Full GC的发生，Survivor的预筛选保证，只有经历16次Minor GC还能在新生代中存活的对象，才会被送到老年代。设置两个Survivor区最大的好处就是解决了碎片化，刚刚新建的对象在Eden中，经历一次Minor GC，Eden中的存活对象就会被移动到第一块survivor space S0，Eden被清空；等Eden区再满了，就再触发一次Minor GC，Eden和S0中的存活对象又会被复制送入第二块survivor space S1（这个过程非常重要，因为这种复制算法保证了S1中来自S0和Eden两部分的存活对象占用连续的内存空间，避免了碎片化的发生）

8、Parallel Old 收集器（多线程标记整理算法）

Parallel Old 收集器是Parallel Scavenge的年老代版本，使用多线程的标记-整理算法，在 JDK1.6才开始提供。

在 JDK1.6 之前，新生代使用 ParallelScavenge 收集器只能搭配年老代的 Serial Old 收集器，只能保证新生代的吞吐量优先，无法保证整体的吞吐量， Parallel Old 正是为了在年老代同样提供吞吐量优先的垃圾收集器， 如果系统对吞吐量要求比较高，可以优先考虑新生代Parallel Scavenge和年老代 Parallel Old 收集器的搭配策略。

9、Java线程具有五中基本状态

**1、**新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread()；

**2、**就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

**3、**运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就 绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

**4、**阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。

根据阻塞产生的原因不同，阻塞状态又可以分为三种：

**1、**等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

**2、**同步阻塞：线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

**3、**其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

**5、**死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

10、双亲委派模型是什么？

类加载器具有等级制度但非继承关系，以组合的方式复用父加载器的功能。双亲委派模型要求除了顶层的启动类加载器外，其余类加载器都应该有自己的父加载器。

一个类加载器收到了类加载请求，它不会自己去尝试加载，而将该请求委派给父加载器，每层的类加载器都是如此，因此所有加载请求最终都应该传送到启动类加载器，只有当父加载器反馈无法完成请求时，子加载器才会尝试。

类跟随它的加载器一起具备了有优先级的层次关系，确保某个类在各个类加载器环境中都是同一个，保证程序的稳定性。

更多Java 面试题70道

01、java中有几种方法可以实现一个线程？

02、Java 中的 HashSet，内部是如何工作的？

03、redux的工作流程?

04、String类的常用方法有那些？

05、请你谈谈对OOM的认识

06、ParNew 垃圾收集器（Serial+多线程）

07、Java 中如何格式化一个日期？如格式化为 ddMMyyyy 的形式？

08、什么是Java虚拟机

09、Java 中的同步集合与并发集合有什么区别？

10、适配器模式和代理模式之前有什么不同？

11、说说G1垃圾收集器的工作原理

12、JRE、JDK、JVM 及 JIT 之间有什么不同？

13、当父类引用指向子类对象的时候，子类重写了父类方法和属性，那么当访问属性的时候，访问是谁的属性？调用方法时，调用的是谁的方法？

14、堆溢出的原因？

15、说一下 runnable 和 callable 有什么区别

16、JVM 类加载机制

17、怎么打破双亲委派模型？

18、垃圾收集算法

19、你有哪些手段来排查 OOM 的问题？

20、假设把实例化的数组的变量当成方法参数，当方法执行的时候改变了数组内的元素，那么在方法外，数组元素有发生改变吗？

21、怎么获取 Java 程序使用的内存？堆使用的百分比？

22、强引用、软引用、弱引用、虚引用是什么？

23、G1 收集器

24、运行时常量池溢出的原因？

25、Java最顶级的父类是哪个？

26、JVM 监控与分析工具你用过哪些？介绍一下。

27、JVM新生代中为什么要分为Eden和Survivor？

28、Parallel Old 收集器（多线程标记整理算法）

09、Java线程具有五中基本状态

30、双亲委派模型是什么？

31、什么是方法内联？

32、你对线程优先级的理解是什么？

33、Java是否需要开发人员回收内存垃圾吗？

34、说说Java 垃圾回收机制

35、volatile 变量和 atomic 变量有什么不同？

36、JVM 内存区域

37、JVM 有哪些运行时内存区域？

38、Spring中Bean的作用域有哪些？

39、String str=”aaa”,与String str=new String(“aaa”)一样吗？

40、什么是建造者模式

41、为什么HashMap中String、Integer这样的包装类适合作为K？

42、常见的计算机网络协议有那些？

43、一个线程运行时发生异常会怎样？

44、遍历一个 List 有哪些不同的方式？每种方法的实现原理是什么？Java 中 List 遍历的最佳实践是什么？

45、StringBuffer，Stringbuilder有什么区别？

46、什么是线程池？

47、JDBC操作的步骤

48、说一下 JVM 调优的工具？

49、JVM 提供的常用工具

50、SynchronizedMap和ConcurrentHashMap有什么区别？

51、有哪些类加载器？

52、mixin、hoc、render props、react-hooks的优劣如何？

53、什么是Executors？

54、如何判断对象是否是垃圾？

55、volatile 类型变量提供什么保证？

56、在 Java 程序中怎么保证多线程的运行安全？

57、线上常用的 JVM 参数有哪些？

58、volatile 关键字的作用

59、解释何时在Tomcat使用SSL ?

60、使用js获取一个表单元素

61、Sql优化有那些方法？

62、用 Java 写一个线程安全的单例模式（Singleton）？

63、在 Java 中，对象什么时候可以被垃圾回收？

64、线程的 run()和 start()有什么区别？

65、重排序实际执行的指令步骤

66、Java中异常分为哪两种？

67、什么是并发容器的实现？

68、创建线程的四种方式

69、Java 中，直接缓冲区与非直接缓冲器有什么区别？

70、poll() 方法和 remove() 方法的区别？

如果不背 Java面试题的答案，肯定面试会挂！

这套Java面试题大全，希望对大家有帮助哈~

博主已将以下这些面试题整理成了一个Java面试手册，是PDF版的

最后

以上就是糟糕毛巾为你收集整理的110道Java初级面试题及答案（最新Java初级面试题大汇总）的全部内容，希望文章能够帮你解决110道Java初级面试题及答案（最新Java初级面试题大汇总）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。