前言

根据自己从业这么多年，想汇总一下Java面试题，希望能帮助那些能看到我博客的人，只希望帮助你😀，哈哈💪

题目如下：

Java是什么?

首先我们要知道我们Java语言是什么，通过了解我们才能知道怎么用它😀，开始我们的骚操作^_^

简单和面向对象:Java语言的语法相对简单,面向对象程序设计使其具有扩展性和重用性。
分布式:Java具有"Write Once, Run Anywhere"的特性,程序可以在多个不同的计算机平台上运行,一个编译后的Java程序可以在支持Java的操作系统和机器上运行。
健壮性:Java提供的大量api和语言特性可以强制程序员编写健壮的程序。如:必须处理或者抛出异常等。
安全性:Java提供了一个安全机制来防止恶意程序窃取数据或破坏系统。另外,它的"Sandbox"模型限制了Java程序可以做的事情。
体系结构中立:Java的编译代码是中立的,不依赖于某个特定的处理器架构。
解释性:Java使用解释器将字节码转换成机器代码,这让Java程序在各个不同操作系统上都能运行。
高性能:尽管Java被广泛认为不是一门高性能语言,但在实际运行环境中,Java的性能表现却非常优异。这归功于Java的编译器和JIT(Just-In-Time)编译器。
多线程:Java内置支持多线程,可以轻松实现高并发程序。
垃圾收集:Java具有自动内存管理机制,可以自动回收不再需要使用的内存空间。程序员不需要手动的释放内存。

总的来说,Java具有简单、面向对象、分布式、健壮、安全、中立、解释性、高性能、多线程和自动内存管理等主要特点。它的"Write Once, Run Anywhere"理念,极大的扩展了其在开发和应用方面的范围。Java已成为目前最流行的编程语言之一。

😀 开始我们的正题，进行分享面试题，

ヾ(◍°∇°◍)ﾉﾞ

JDK和JRE的区别是什么?

JDK:Java Development Kit,Java开发工具包,用于开发Java程序。

它包含了Java运行环境JRE,以及开发人员使用的工具(编译器javac、调试器jdb等)。

JRE:Java Runtime Environment,Java运行环境。

它是运行已编译Java程序所需的环境。

它包含Java虚拟机JVM,库和其他Java SE组件。

但是不包含开发工具如编译器和调试器。

总的来说:

1. JDK主要用于Java开发人员,JRE主要面向Java运行程序的最终用户。
2.  JDK包含JRE,但是JRE不包含JDK。开发Java程序需要JDK,运行Java程序只需要JRE。
3.  JDK包含开发工具,比如编译器javac和调试器jdb,JRE不包含这些开发工具。
4.  JRE包含Java虚拟机JVM,库和其他Java SE API,JDK也同样包含这些组件。
5.  JDK版本更新比JRE版本更新快,因为JDK同时需要更新开发工具。每次JDK升级都会带来JRE的升级。所以总结来说,JDK主要用于开发Java程序,JRE主要用于运行Java程序。如果我们要运行已经开发好的Java程序,只安装JRE即可;如果要开发Java程序,就需要安装JDK。

什么是Java虚拟机那它工作?

Java虚拟机(JVM)是Java运行环境的一部分,它是一个规范,用于解释执行Java字节码并为Java程序提供运行环境。

JVM允许Java程序在不同的硬件体系结构和操作系统平台上运行。

JVM的工作流程如下:
1. 编译:将Java源代码(.java文件)编译成Java字节码(.class文件),这是Java程序与平台无关的格式。
2. 加载:JVM将字节码文件加载到内存中,检查文件是否有错误,如果正确无误,将内存中创建一个Class对象来表示该类。
3. 链接:JVM将Class对象与其需要的其他Class对象关联起来,如果需要的Class对象不存在,会抛出异常。
4. 初始化:为Class对象中的静态变量分配内存空间,并为其指定默认初始值。
5. 运行:运行Java程序包含三个子阶段:- 调用和返回指令的执行:
  
  JVM从调用方法处开始执行字节码,直到遇到方法返回指令,然后返回调用点继续执行。
  
  异常处理:如果字节码中包含任何可能引发异常的操作,则JVM将检查是否有匹配的异常处理程序。如果有,则将其跳转到异常处理程序处。
  
  线程的调度和执行:如果正在运行的Java程序有多个线程,则JVM将在线程之间进行切换,以便所有线程都得到执行。
  1. 卸载:GC释放与Class对象关联的内存空间。Class对象随即变得不可用。JVM允许Java程序在不同平台上运行的关键在于将Java源代码编译成平台无关的字节码,然后由JVM在目标平台上解释执行该字节码。
什么是Java源代码中的包?

在Java中,包(package)是一个文件夹的概念。

它有以下几个作用:
1. 避免命名冲突:通过使用不同的包名,我们可以将有相同名称的类区分开来,避免命名冲突。例如java.util和java.sql包中都有Date类,通过包名我们可以明确地区分这两个类。
2. 方便引用:通过使用包名,我们可以方便地引用包内的类。例如java.util.Date类。
3. 控制访问权限:我们可以通过包来控制类和接口的访问权限。在同一个包内的类可以相互访问。不同包的类访问需要使用public修饰符。
4. 命名空间:包可以将相关的类和接口组织在同一个命名空间下,方便管理和使用。包的定义很简单,在源代码的首行使用package关键字,后跟包名,例如:
```
java
package com.example.foo;

public class MyClass {
   // ...
} 
```
这个MyClass类位于com.example.foo包中。包名通常使用域名的反向表示法,例如com.example.foo。包在编译时不会产生class文件,但是会影响.class文件的存放路径。上例的MyClass类文件会生成为com/example/foo/MyClass.class。
什么是关键字和保留字?

在Java中,关键字和保留字是有区别的:关键字:

是Java语言中有特殊含义的词,用于控制程序结构和实现特定功能。
关键字不能用于其他目的,例如不能作为变量名或方法名。
例如:if、for、public、class等。保留字:- 是因为现有或将来的Java版本中会有特殊含义而保留的词。
目前版本中未作为关键字使用,但是以后版本中可能会变为关键字。
例如:goto、const。为了兼容未来可能的语言变化,建议不要使用保留字作为标识符(变量名、方法名等)。举个例子,在早期的Java版本中enum是一个保留字,在Java 5中变为关键字,用于定义枚举类型。

如果在早期版本中你定义了一个名为enum的变量,在升级到Java 5后就会产生语法错误。

总结:
- 关键字是语言结构中的一定会用到的词,用来控制程序流程和声明访问修饰符或其他类型。
  - 保留字是目前版本尚未使用,但以后版本可能会变为关键字的词。
  - 两者共同点是都不能用作标识符。不同点是关键字目前版本就已经在使用,保留字是防止以后版本用作关键字。关键字列表和保留字列表可以在Java语言规范中找到。
什么是变量和数据类型?

变量:- 变量是内存中的一个存储区域,用于存储数据。
- 每个变量都有一个名称和一个数据类型。
- 变量必须在使用前声明,声明时需要指定名称和数据类型。
- 例如:int age; // 声明一个整数变量age数据类型:- 每个变量都必须有一个数据类型,它决定了变量中存储数据的类型和大小。
- Java是一门强类型语言,它要求变量的使用必须与声明的数据类型一致。
- Java提供了8种基本类型:byte、short、int、long、float、double、char和boolean。
- 除基本类型外,还有引用类型,例如String、Scanner等。举些例子:
```
java
// 声明基本类型变量
int age = 20; 
char ch = 'A';
double score = 98.5;
boolean flag = true;

// 声明引用类型变量
String name = "Ming"; 
Scanner scan = new Scanner(System.in);
```
变量和数据类型是编程语言的基石,熟练掌握它们是学习任何语言的基础。总结如下:
- 变量:内存中用于存储数据的区域。有名称和类型。
  - 数据类型:决定变量中数据的类型和大小。Java有8种基本类型和引用类型。
  - 变量需要声明后才能使用,声明时指定名称和类型。
  - Java是强类型语言,变量的使用必须与声明的类型一致。
什么是操作符? 列举Java支持的所有操作符。
if-else语句和switch语句的差异是什么?
什么是循环结构? Java支持哪些循环结构?
什么是数组? 为什么 Java 中只有一维数组?
访问修饰符有哪些?
面向对象的特征有哪些?
类和对象的区别是什么?
在 Java 中构造方法的作用是什么?
方法重载和方法重写的区别是什么?

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

3、final 在 java 中有什么作用？

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

5、String 属于基础的数据类型吗？

6、String str="i"与 String str=new String(“i”)一样吗？

7、如何将字符串反转？

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

9、new String("a") + new String("b") 会创建几个对象？

10、如何将字符串反转？

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

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

13、接口和抽象类有什么区别？

14、java 中 IO 流分为几种？

15、BIO、NIO、AIO 有什么区别？

16、Files的常用方法都有哪些？

17、什么是反射？

18、什么是 java 序列化？什么情况下需要序列化？

19、为什么要使用克隆？如何实现对象克隆？深拷贝和浅拷贝区别是什么？

20、throw 和 throws 的区别？

21、final、finally、finalize 有什么区别？

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

23、常见的异常类有哪些？

24、hashcode是什么？有什么作用？

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

26、java 中都有哪些引用类型？

27、在 Java 中，为什么不允许从静态方法中访问非静态变量？

28、说说Java Bean的命名规范

29、Java Bean 属性命名规范问题分析

30、什么是 Java 的内存模型?

31、在 Java 中，什么时候用重载，什么时候用重写？

32、举例说明什么情况下会更倾向于使用抽象类而不是接口？

33、实例化对象有哪几种方式

34、byte类型127+1等于多少

35、Java 容器都有哪些？

36、Collection 和 Collections 有什么区别？

37、list与Set区别

38、HashMap 和 Hashtable 有什么区别？

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

40、set有哪些实现类？

41、说一下 HashSet 的实现原理？

42、ArrayList 和 LinkedList 的区别是什么？

43、如何实现数组和 List 之间的转换？

44、在 Queue 中 poll()和 remove()有什么区别？

45、哪些集合类是线程安全的

46、迭代器 Iterator 是什么？

47、Iterator 怎么使用？有什么特点？

48、Iterator 和 ListIterator 有什么区别？

49、怎么确保一个集合不能被修改？

50、队列和栈是什么？有什么区别？

51、Java8开始ConcurrentHashMap,为什么舍弃分段锁？

52、ConcurrentHashMap(JDK1.8)为什么要使用synchronized而不是如ReentranLock这样的可重入锁？

53、concurrentHashMap和HashTable有什么区别

54、HasmMap和HashSet的区别

55、请谈谈 ReadWriteLock 和 StampedLock

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

57、为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？

58、Synchronized 用过吗，其原理是什么？

59、JVM 对 Java 的原生锁做了哪些优化？

60、为什么 wait(), notify()和 notifyAll()必须在同步方法或者同步块中被调用？

61、Java 如何实现多线程之间的通讯和协作？

序列化和反序列化是什么?

序列化是将对象转换为字节序列的过程,用于存储对象或在网络中传输对象。
反序列化是将字节序列恢复为对象的过程。使用序列化可以将对象状态保存为字节序列,并在需要时可以通过反序列化将字节序列还原为对象。

transient关键字的作用是什么?
transient关键字用来表示一个字段不是该对象串行化的一部分。当一个对象被串行化的时候,标记为transient的变量的值不包括在串行化的表示中。
synchronized和volatile的区别是什么?
synchronized:用于线程同步,可以保证被它修饰的方法或代码块在同一时刻只能被一个线程访问。主要针对线程之间访问资源的同步性。volatile:用于线程之间的可见性。一个volatile变量的修改对所有的线程都是可见的,线程会从主内存中读取最新值。但它不保证原子性。总结:synchronized:同步,解决线程安全问题。
volatile:可见性,让线程可以及时获取其它线程对这个变量的修改的值。
sleep()和wait()方法的区别是什么?
sleep():1. 让当前线程停止执行指定的毫秒数。
它可以用于任何线程。
它导致线程转入阻塞状态。
它不会释放锁定资源。wait():1. 让当前线程等待其他线程唤醒。
它只能在同步方法或同步块中使用。
它会释放线程持有的锁。
它需要和notify()或notifyAll()配合使用。sleep()使一个线程停止执行一定时间,而wait()可以让一个线程停止执行直到其他线程通知。sleep()方法不会释放锁,而wait()方法会释放锁。这是两个方法最主要的区别。

66.Java中I/O流有几种类型?分别有什么作用?

Java的I/O流主要分为四种:1. 字节流:用于读写8位的字节,常用的类有InputStream和OutputStream。用于操作原始的二进制数据。2. 字符流:用于读写16位的Unicode字符,常用的类有Reader和Writer。特别适合文本文件的读写。3. 缓冲流:对4种基本流的包装,提高流的读写效率。常用的类有BufferedReader。4. 数据流:用于读写Java的基本数据类型,常用的类有DataInputStream和DataOutputStream。这4种流分别代表了不同的操作对象和角色,但可以相互嵌套使用以满足不同的需求。比如字符流就常常包装在缓冲流里使用。

File类和IO流之间的区别是什么?
File类主要用于读取文件属性,而IO流主要用于读取文件数据。主要区别:1. File类操作文件,IO流操作数据流。File类用于获取文件大小,修改时间等信息,而IO流用于读取文件内容。2. File类没有读写功能,它只能创建、删除、重命名文件和目录。IO流才具有读写功能。3. File类对象可以用于构造IO流对象。以InputStream为例,就可以接收一个File对象作为参数。4. IO流需要与File对象配合才能完成文件的读写操作。File对象指明读写文件,IO流才具体执行读写。所以总结来说:File类用于操作文件,IO流用于操作流式数据。File类可以用于构造IO流,IO流需要File对象来完成文件读写操作。
InputStreamReader和OutputStreamWriter的作用是什么?

InputStreamReader:将一个字节输入流转换为字符输入流。可以指定字符集来解码字节,默认使用UTF-8。OutputStreamWriter:将一个字符输出流转换为字节输出流。可以指定字符集来编码字符,默认使用UTF-8。主要作用是作为字节流和字符流的桥梁,通过指定字符集来完成编码和解码。

什么是 Java 序列化? 为什么要序列化?
序列化是一种将对象转换成二进制字节流的机制,用于支持对象的持久存储(如文件、数据库)和网络传输(RMI、Socket)等。主要目的:1. 持久化:可以将对象状态保存到存储媒体(如文件、数据库)或者通过网络传输。2. 网络传输:可以在网络上传输对象。3. 深拷贝:可以实现对象的深拷贝。4. 轻量级的对象传输协议:简单高效的对象封送格式。
什么是反射?给出应用场景?
反射是Java被编译后的字节码的能力,允许程序在运行时检查或 dynamically构造类和对象。主要应用场景:1. 调试工具:获取类的各种元数据信息。2. 框架设计:通过反射来获取对象的信息以及动态创建对象。3. 修改私有字段:反射可以访问私有字段,用于调试或者测试。4. 类浏览器和可视化开发环境:通过反射获取类的各种信息用于显示。5. 动态代理:通过反射实现动态代理的关键步骤。6. 注解:反射是实现注解的基础。7. ORM框架:通过反射来映射Java对象到数据库表。总之,反射的主要作用在与框架设计和元数据信息的获取上。它允许我们在运行时发现和操作类的信息。
什么是动态代理?它的实现方式有哪些?动态代理有什么作用?
动态代理是一种在运行时根据需要动态创建目标对象的代理对象的机制。实现方式主要有两种:1. 基于接口的动态代理:使用JDK中提供的Proxy类和InvocationHandler接口实现。2. 基于继承的动态代理:使用第三方库如CGLIB实现。主要作用:1. 对目标对象的访问进行控制和增强。2. 降低系统的耦合度,提高灵活性。动态代理可以在不修改原对象代码的情况下对其进行增强。3. 提供更好的扩展性,可以在运行时根据需要动态创建代理对象。4. AOP的实现方式之一。动态代理是实现AOP的关键。用动态代理主要是为了在运行时動態的對某個對象生成一
Java 中的异常处理是什么? 异常的分类有哪些?

异常处理是一种处理程序在运行时发生的异常情况的机制。主要包括:1. 抛出异常:使用 throw 语句。

捕获异常:使用 try ... catch 语句。
声明异常:在方法声明中使用 throw 关键字。异常主要分为两大类:1. 检查性异常:需要用 try...catch... 语句捕获并进行处理,如IOException。
运行时异常:如NullPointerException,不需要强制捕获,如果没有捕获也不会报错。异常的分类体系:Error:严重错误,程序不会捕获。Exception:程序可以捕获并处理的异常。· RuntimeException:运行时异常,不需要强制处理。· Checked Exception:需要强制捕获处理的异常,如IOException。所以总结来说,异常用于在程序运行时处理错误和其它异常条件。它使程序更健壮,并能继续执行。异常分为Error和Exception,Exception又分为Checked Exception和Runtime Exception。73. final、finally和finalize的区别是什么?

final:1. 可以用于修饰类、方法和变量。

修饰类,该类不能被继承。
修饰方法,该方法不能被重写。
修饰变量,该变量只能被赋值一次,成为常量。finally:1. 用于保证某段代码一定会被执行。
主要用于资源释放。
可以和try、catch一起使用,不管是否发生异常,finally中的代码都会执行。finalize:1. 用于资源回收,当对象垃圾回收时会执行。
由垃圾回收线程调用,不能由我们直接调用。
只会被调用一次。所以主要区别是:final用于修饰类、方法和变量,表示最终特征。

finally用于保证一段代码肯定会被执行,主要用于资源释放。
finalize用于资源回收,由垃圾回收线程调用,只会调用一次。

Java中的包是什么?有什么用?
包(package)是组织Java类的一种方式。主要作用是:1. 避免名称冲突:不同包下可以有相同的类名。2. 提高可维护性:合理的包结构可以更好的组织类和接口。3. 控制访问权限:包同一个目录下的类和接口有访问权限,不同包则没有。4. 命名空间:包作为类和接口的命名空间。使用package声明来定义包,package声明应位于源文件的首行。一个.java文件只能属于一个包,但可以包含多个类和接口。如果没有使用package关键字,那么默认属于"无名包",只能有一个无名包的.java文件。包的路径按层级关系使用 "." 分隔。包有访问控制权限,同一个包下的类和接口有访问权限。不同包的话,需要使用public修饰符。所以总结来说,包主要用于组织类和接口,控制访问权限,防止命名冲突。它实现了一种命名空间的概念。
String类是final的吗?为什么?
String类是final的,意味着它不可被继承。主要原因:1. 保证String类对象的唯一性。如果它可以被继承,那么就存在不同的String类型,这会引起字面量"abc"到底是哪一个String类型的困扰。2. 字符串常量池的实现依赖String类被声明为final。
Math类和StrictMath类的区别是什么?

Math和StrictMath类都提供各种数学函数,区别主要是:Math类:1. 部分方法调用本地方法,部分调用Java方法。

方法采用IEEE 754标准,结果会有误差。
速度较快。StrictMath类:1. 所有方法都是Java方法,没有调用本地方法。
方法采用四舍五入规则,结果精确。
速度较慢。所以主要区别是精度不同,一个速度快精度略低,一个精度高速度略慢。如果需要高精度计算,推荐使用StrictMath类。77. Comparable和Comparator的区别是什么?

Comparable和Comparator都是用于排序的接口,主要区别是:Comparable:1. 自然排序:对象实现Comparable接口后可以自然排序。

接口中的compareTo方法只有一个参数,用于和本对象进行比较。
需要实现compareTo方法完成排序逻辑。
只能有一个排序规则,重写compareTo方法后排序规则就确定了。Comparator:1. 定制排序:Comparator为某个类的对象提供多种排序方式。
接口中的compare方法有两个参数,用于比较两个不同的对象。
需要实现compare方法来定制排序逻辑。
可以有多个Comparator来实现不同的排序规则。总结:Comparable用于类的自然排序,只能有一种排序规则。

Comparator用于定制排序,可以有多种排序规则。
如果需要多种排序规则,优先考虑Comparator,如果只需要自然排序一种规则,那么实现Comparable接口即可。78. HashSet如何判断两个对象相等?
HashSet判断两个对象相等主要依赖两个方法:1. hashCode():返回对象的hash值,用于确定对象在HashSet中的存储位置。2. equals():判断两个对象的逻辑相等性。当我们把对象添加到HashSet中时,HashSet会先调用hashCode()来得到该对象的hash值,然后根据hash值将对象存储在相应的位置上。在HashSet判断两个对象是否相等时,会这么判断:1. 先判断两个对象的hash值是否相等,如果不相等,则两个对象不相等,如果相等,再进行第二步。2. 调用第一个对象的equals()方法,传入第二个对象作为参数,来判断逻辑相等性。3. 所以,两个对象相等的条件是:两个对象的hash值相等,并且第一个对象的equals()方法返回true。4. 如果我们没有重写equals()和hashCode()方法,那么默认情况下比较的是对象的地址值,地址值相等则判定两个对象相等。所以结论是:想要我们的对象能够正确的存储和取出于HashSet中,必须重写equals()和hashCode()方法,通过逻辑判断两个对象是否真正相等。如果不重写这两个方法,默认比较的是对象的地址,这是错误的。79. HashMap的工作原理?
HashMap基于哈希表的Map接口实现,主要特点是:1. 允许key为null,但最多只能有一个key为null,value可以有多个为null。

非线程安全,线程不安全的,性能较高。
基于拉链法实现,内部包含数组和链表。
默认初始容量为16,负载因子为0.75。工作原理:1. 根据key的hashCode计算hash值:hash = hashCode() ^ (hashCode() >>> 16)。
hash值确定该key-value在数组中的位置(索引),如果此位置为空,直接插入。
如果此位置上已经存在元素(冲突),则比较key的equals方法,相等则替换value,不等则采用拉链法
HashMap的put方法原理是什么?

HashMap的put方法用于插入键值对,原理主要如下:1. 计算key的hash值,然后根据hash值确定其在数组中的位置(索引)。

如果数组该位置为空,直接插入新元素。
如果该位置上已经有元素,则判断该元素与新元素的key是否相等:3.1 如果相等,使用新值替换旧值。

3.2 如果不相等,则采用拉链法处理冲突,将新元素插入链表的尾部。4. 如果链表长度超过8,会先将链表转换成红黑树,以改进搜索效率。具体代码如下:

java
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

这里涉及到TreeNode、链表、数组、resize()、treeifyBin()等知识,比较复杂,需要具体分析源码才能完全理解put方法的实现原理。

ArrayList和LinkedList的区别是什么?
ArrayList和LinkedList都是List接口的实现类,但是底层数据结构不同:ArrayList:基于动态数组实现,支持随机访问。LinkedList:基于双向链表实现,只支持顺序访问。两者的主要区别是:1. 是否保证线程安全:ArrayList是非线程安全的,LinkedList是线程安全的。2. 底层数据结构:ArrayList底层是Object数组;LinkedList底层是双向链表。3. 插入和删除是否受元素位置的影响:ArrayList插入和删除元素的时间复杂度受元素位置的影响是O(n);LinkedList的时间复杂度是O(1)。4. 是否支持高效的随机访问:ArrayList支持高效的随机访问,时间复杂度是O(1);LinkedList不支持高效的随机访问,时间复杂度是O(n)。5. 内存占用:ArrayList的空间浪费主要体现在list list.size()之外的数组空间;LinkedList的空间花销主要体现在它的每一个元素都需要消耗相当的空间来存储直接后继和直接前驱的元素。6. ArrayList扩容机制:当ArrayList容量不足以包含

所有元素时,容量会加倍增长。LinkedList的容量是动态的,无需考虑扩容问题。所以总结来说:ArrayList:基于数组,支持随机访问,相对占用内存小,插入删除涉及元素移动,线程不安全。
LinkedList:基于链表,不支持随机访问,相对占用内存大,插入删除不涉及元素移动,线程安全。选择使用的关键在于是否需要随机访问和线程安全,如果需要随机访问但不需要线程安全,选择ArrayList;如果需要线程安全但不需要随机访问,选择LinkedList。

HashSet、LinkedHashSet和TreeSet有什么区别?
HashSet、LinkedHashSet和TreeSet都是Set接口的实现类,但是底层数据结构不同:HashSet:底层采用HashMap,元素无序,访问速度快。LinkedHashSet:底层采用LinkedHashMap,元素有序,访问速度一般。TreeSet:底层采用TreeMap,元素有序,但访问速度最慢。三者的主要区别是:1. 元素排序:HashSet无序;LinkedHashSet按元素插入顺序排序;TreeSet按元素大小自然排序或定制排序。2. 访问速度:HashSet最快;LinkedHashSet次之;TreeSet最慢。HashSet采用散列表,时间复杂度是O(1);其他两个底层采用不同的树形结构,时间复杂度是O(logN)。3. 是否允许重复:都不允许重复元素。4. 是否线程安全:都不是线程安全的,如果需要线程安全的Set,可以使用Collections类中的synchronizedSet方法把Set包装为线程安全的。5. 使用场景:HashSet:用于需要快速查找和不需要排序的场景。
LinkedHashSet:用于需要维护元素插入顺序的场景。
TreeSet:用于需要排序的场景,且排序规则不固定的情况下。所以总结来说,主要区别在于元素排序和访问速度,根据实际需要选择不同的Set实现类。但 none是线程安全的,如果concern性能的话可以使用HashSet。
Map中常用的方法有哪些?
Map接口定义了很多方法,常用的主要有:1. V put(K key, V value):添加元素。2. V remove(Object key):移除元素,通过key移除值。3. V get(Object key):根据key获取值。4. boolean containsKey(Object key):判断Map中是否包含该key。5. boolean containsValue(Object value):判断Map中是否包含该value。6. void clear():清空Map。7. boolean isEmpty():判断Map是否为空。8. int size():获取Map中的元素个数。9. Set keySet():获取Map中所有的key,以Set集合形式返回。10. Collection values():获取Map中所有的value,以Collection集合形式返回。11. Set<Entry<K, V>> entrySet():获取Map中所有的key-value对,以Set<Entry<K, V>>形式返回。12. V putIfAbsent(K key, V value):仅当指定的key尚未与值关联时才将其与给定的值关联。13. boolean replace(K key, V oldValue, V newValue ):仅当当前指定键的归值等于旧值时,才将其与新值相关联。14. V replace(K key, V value):将指定键的值替换为给定的新值。15. V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) :如果指定的键尚不存在与其关联的值,则使用给定的映射函数来将键映射到值,并与之关联。这些方法涵盖了Map常用的功能,可以完成元素的增、删、改、查操作。
equals()和hashCode()的关系是什么?

equals()方法用于判断两个对象是否相等,hashCode()方法用于获取对象的哈希值。它们的关系是:1. 如果两个对象相等,则hashCode一定相同。

两个对象hashCode相等,对象不一定相等。相等的含义是:equals()方法返回true。这是因为:1. hashCode()的返回值是一个整数,相等的两个对象可以有相同的hash值,但是不同的对象也有可能具有相同的hash值,这称为"hash冲突"。
相等的两个对象必须有相同的hash值,这个是equals()和hashCode()的契约。如果equals()返回true,但hashCode()返回不同的值,则会违反这个契约,对象不能正确的存储在HashMap、HashSet等集合中。所以总结为:1. 相等的对象必须具有相同的散列码
具有相同散列码的对象不一定相等具体实现的时候,需要遵守以下规则:1. 在覆盖equals()方法时应总是覆盖hashCode()方法,保证相等的两个对象hash值也相等。2. hashCode()的计算应该使用equals()方法中用到的字段,而不应该仅使用用于实例标识的字段。3. 用于计算hashCode的字段越多,两种对象被视为逻辑相等的可能性越小,因此hashCode值会分布的更均匀,冲突的可能性更小。4. hashCode()方法的返回值应随机分布于整个整数范围内,减小冲突的可能。5. 如果hashCode()的计算方式发生变化,会影响HashMap,HashSet等集合中的元素位置,因此hashCode()方法一旦被覆盖,就不应该变动。6. 重写hashCode时应保证线程安全。所以总结来说,equals()和hashCode()之间有着密切的联系,遵循契约和规则,可以使对象能够正确的存储于Hash集合中。

85.ConcurrentHashMap的原理与实现?

ConcurrentHashMap是线程安全的HashMap,采用分段锁技术实现线程安全,在不影响并发度的情况下,实现线程安全。

主要原理是:

            1.     分段锁:将数据分成一段一段的存储,每一段数据对应一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问。
            2. HashEntry:类似HashMap的Node,但不存放key和value,而是存放段号和链表首节点。
            3.  链表:与HashMap相同,采用拉链法解决冲突。
            4.  红黑树:当某一段的链表长度太长(默认超过8),会将链表转换为红黑树,以提高效率。
            5. 主要实现是:
                    1.  初始化时,根据CPU核数和并发级别,计算分成多少段。默认是16段。
                    2.  key的hash值对段数取模得到该key存放在哪一段。3. 每一段对应一把锁,线程占用锁后,可以访问对应段中的链表。4. put时,锁定key所在段,判断hashEntry是否存在,不存在则创建,存在则直接插入链表。5. 同样的,get也需要锁定对应的段,再从该段的链表或红黑树中获取元素。6. size方法也需要锁定每个段,遍历整个表并统计大小,该操作代价高昂,不建议频繁使用。

所以总结来说,ConcurrentHashMap使用分段锁技术,将数据分段存储,每段数据对应一锁,加锁后可以操作对应段的数据, meanwhile其他段也可以被其他线程访问,这样实现了并发度的提高。同时也采用了链表和红黑树的混合结构,实现了可扩容,且不影响并发。这种结构相比HashMap来说,性能更高,功能也更强大,是高并发场景下最好的Map选择。

volatile和synchronized的区别是什么?

volatile和synchronized都是Java中实现线程安全的关键字,但是存在以下区别:volatile:1. 保证变量的修改对各个线程立即可见。

不能保证原子性。
不能用于修饰方法和代码块。
读写速度较快,但不能替代synchronized达到线程同步的效果。synchronized:1. 可以保证变量的修改对各个线程立即可见,也能保证原子性。
可以修饰方法和代码块。
读写速度较慢,能实现线程互斥和线程同步。主要区别是:volatile能保证数据的可见性,但不能保证原子性和互斥性;

synchronized能保证原子性、可见性和互斥性,具有互斥锁的语义,实现线程同步。所以:1. 如果只需保证可见性,使用volatile。

如果需要保证原子性和互斥性,使用synchronized。具体使用场景:volatile:

主要用于解决指令重排序问题,保证数据的可见性。
例如单例模式中的double check实现。synchronized:
可重入互斥锁,实现线程同步,保证数据一致性。
例如循环 CAS 实现的线程安全单例模式。所以总结来说,volatile和synchronized有各自的使用场景,volatile实现轻度同步,synchronized实现重度同步。根据需求选择使用。

Java中的线程有哪几种状态?Java中的线程状态一般有以下几种:1.NEW:当创建一个线程对象时,它的状态就是NEW。2.RUNNABLE:当调用线程的start()方法后,线程进入到RUNNABLE状态。3.BLOCKED:当线程执行某个代码块时,线程进入到BLOCKED状态,直到代码块执行完毕则返回到RUNNABLE状态。4.WAITING:当线程调用wait()方法,线程进入WAITING状态。5.TIMED_WAITING:当线程调用sleep()或wait(long)等带有超时参数的方法时,线程进入TIMED_WAITING状态。6.TERMINATED:当线程完成它的任务或抛出未捕获的异常并终止时,线程进入TERMINATED状态。线程状态之间的转换图:
线程状态转换图这些状态之间的转换由对应方法完成:1.start():NEW -> RUNNABLE
2.运行中:RUNNABLE <-> BLOCKED
3.wait():RUNNABLE -> WAITING
4.notify():WAITING -> RUNNABLE
5.sleep():RUNNABLE -> TIMED_WAITING
6.终止:RUNNABLE -> TERMINATED

88.sleep()方法和wait()方法的区别是什么?
sleep()和wait()方法都是使线程放弃时间片,主要区别是:sleep():1. 让线程进入TIMED_WAITING状态,可以在指定的时间后自动恢复RUNNABLE状态。

方法声明为Thread.sleep(),是Thread类的静态方法。
时间到后会自动恢复,不需要其他线程唤醒。
可以在任意位置调用。wait():1. 让线程进入WAITING状态,需要其他线程调用notify()或notifyAll()唤醒。
方法声明为Object.wait(),是Object类的实例方法。
需要其他线程唤醒,否则会一直等待。
只能在同步方法或同步块中调用,否则会抛出IllegalMonitorStateException。主要区别在于:1. 线程状态不同:sleep()使线程进入TIMED_WAITING状态;wait()使线程进入WAITING状态。
是否需要唤醒:sleep()会自动唤醒;wait()需要其他线程调用notify()或notifyAll()唤醒。
使用位置不同:sleep()可以在任何位置使用;wait()只能在同步方法或同步块中使用。总结:sleep()使线程睡眠指定时间,可以在任意位置使用。

wait()使线程一直等待,必须在同步方法或同步块中使用,需要其他线程唤醒。如果需要定时执行任务,使用sleep();
如果需要唤醒机制,使用wait()和notify()实现线程间通信。

notify()和notifyAll()方法的区别是什么?
notify()和notifyAll()都是用来唤醒线程的方法,主要区别是:notify():随机唤醒一个等待线程。notifyAll():唤醒所有等待线程。这两个方法都需要在同步方法或同步块中使用,否则会抛出IllegalMonitorStateException。使用场景:1. 如果有多个线程等待同一个条件,但你只希望唤醒一个线程,使用notify()。2. 如果有多个线程等待同一个条件,你想唤醒全部等待线程,使用notifyAll()。3. notifyAll()通常会比notify()稍微消耗更多资源,因为它会唤醒更多的线程。4. 如果不确定有多少线程正在等待,或者你不在乎会唤醒哪个具体的线程,使用notifyAll()。示例代码:

java
synchronized (obj) {
    while (<condition does not hold>) 
        obj.wait();
    // ... 
    <modify shared state>
    obj.notify(); // or obj.notifyAll()
    // ...
}

总结:notify()和notifyAll()都需要在同步方法或同步块中使用,用来唤醒等待线程。
notify()随机唤醒一个等待线程,notifyAll()唤醒所有的等待线程。
根据实际需要选择使用notify()还是notifyAll()。如果多个线程等待但只需要唤醒一个,使用notify();如果需要唤醒全部,使用notifyAll()。

Thread和Runnable的区别是什么?
Thread和Runnable都是实现多线程的方式,主要区别是:Thread:1. 继承Thread类,重写run()方法。
启动线程调用start()方法。
编写简单,如果要访问当前线程可以使用this引用。
使得子类继承了Thread不能再继承其他类。Runnable:1. 实现Runnable接口,重写run()方法。
启动线程调用start()方法,需要传递Runnable实现类的对象。
可以继承其他类,更灵活。
无法直接访问当前线程。相同点:1. 都需要重写run()方法,线程执行逻辑在其中定义。
都需要通过线程对象
的start()方法启动线程。主要区别在于:Thread继承了Thread类,而Runnable实现了Runnable接口。
Thread可以直接访问当前线程,Runnable不能。
Thread限定了继承,Runnable更灵活。使用场景:1. 如果需要访问当前线程,使用Thread类。
1. 如果需要继承其他类,使用Runnable接口。
2. 如果两者皆可,建议使用Runnable接口,因为它更灵活,符合面向对象的设计原则。示例代码:Thread类:
```
java
public class MyThread extends Thread {
   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
   }
}
```
Runnable接口:
```
java
public class MyRunnable implements Runnable {
   @Override
   public void run() {
       Thread thread = Thread.currentThread();
       System.out.println(thread.getName());
   } 
}
```
总结:Thread继承Thread类,Runnable实现Runnable接口,都是实现多线程的方式。
主要区别在于Thread可以直接访问当前线程,可继承性较差;Runnable相对更灵活,无法直接访问当前线程。
根据需求选择Thread类或Runnable接口,如果无特殊需求,建议选择Runnable接口。
1. 线程池原理及其重要参数是什么?
  线程池的主要作用是限制和管理系统中线程的数量。线程过多会带来调度开销,占用系统资源,并且有超出系统承载能力的风险;而线程过少会导致系统资源没有充分利用。主要原理是:1. 在应用启动时,创建若干个空闲线程放入线程池。2. 有任务来时,将任务放入任务队列,空闲线程从队列中取出任务并执行。3. 所有任务执行完毕后,空闲线程不会立即销毁,而是继续等待任务。4. 应用退出时,线程会销毁。主要参数:corePoolSize:线程池的基本大小。maximumPoolSize:线程池最大大小。keepAliveTime:空闲线程存活时间。unit:keepAliveTime参数的时间单位。 workQueue:任务队列,存放等待执行的任务。threadFactory:线程工厂,用于创建线程,一般不需要自定义。handler:拒绝策略,当任务过多而线程池处于最大大小时采取的策略。常用拒绝策略:AbortPolicy:直接抛出异常。
  CallerRunsPolicy:使用调用者所在的线程来运行任务。
  DiscardOldestPolicy:丢弃最早的未处理的任务请求。
  DiscardPolicy:直接丢弃任务,不抛出异常。
  默认使用的是AbortPolicy。工作过程:1. 当有新任务来时,如果当前运行线程小于corePoolSize,则创建新线程执行任务。2. 如果运行线程等于或多于corePoolSize,则将任务放入workQueue。3. 如果任务放入workQueue后,队列已满,且运行线程小于maximumPoolSize,则创建新线程执行任务。4. 如果任务放入workQueue后,队列已满,且运行线程等于或多于maximumPoolSize,则使用handler的策略来处理该任务。5. 空闲线程等待keepAliveTime后销毁。所以线程池的主要作用是复用线程,控制线程数量,管理线程。通过上述参数可以实现一个高效且易维护的线程池。
CountDownLatch和CyclicBarrier的区别是什么?

CountDownLatch和CyclicBarrier都是用来协调线程的工具类,主要区别是:CountDownLatch:1. 计数器只能使用一次,计数器的值只能在创建时候初始化或者使用countDown()方法减1。

主要用于某个线程等待多个线程完成各自的工作后再执行。CyclicBarrier:1. 计数器可以循环使用,可以通过reset()方法重置。
主要用于多个线程互相等待,只有当多个线程都到达 barrier 点时,这些线程才会继续执行。相同点:1. 都可以实现线程间的等待。
都依赖于计数器来实现。主要区别:1. CountDownLatch 的计数器只能减少,不能增加,CyclicBarrier 的计数器可以重复使用。
CountDownLatch 主要用于等待事件,CyclicBarrier 主要用于线程同步。使用场景:CountDownLatch:启动一个任务,等待其他任务执行完成后再继续执行,类似门闩。常用于程序的线程同步。CyclicBarrier:多个线程互相等待,任意一个线程完成后所有线程继续执行,类似会议门。常用于多线程计算数据,最后合并计算结果。示例代码:

CountDownLatch:

java
CountDownLatch countDownLatch = new CountDownLatch(3);

new Thread(() -> {
    System.out.println("child thread 1");
    countDownLatch.countDown();
}).start();

new Thread(() -> {
    System.out.println("child thread 2");
    countDownLatch.countDown(); 
}).start();  

new Thread(() -> {
    System.out.println("child thread 3");
    countDownLatch.countDown();
}).start();

countDownLatch.await();  
System.out.println("main thread");

CyclicBarrier:

java 
CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

new Thread(() -> {
    System.out.println("child thread 1"); 
    try {
        cyclicBarrier.await();
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    } 
}).start();

new Thread(() -> {
    System.out.println("child thread 2"); 
    try {
        cyclicBarrier.await();
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
}).start();   

new Thread(() -> {
    System.out.println("child thread 3");
    try {
        cyclicBarrier.await();
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace(); 
    }    
}).start();

System.out.println("main thread");

总结:CountDownLatch和CyclicBarrier都能实现线程间的等待,主要区别在于计数器的使用方式不同,CountDownLatch用于等待事件,CyclicBarrier用于线程同步。

线程的基础同步工具有哪些?

Java提供了三种基础同步工具:1. synchronized:通过锁定对象或代码块来实现同步。

volatile:通过屏蔽指令重排序来保证多线程环境下变量的可见性。
Atomic:通过无锁编程实现原子性操作。这三种同步工具各有不同的应用场景:synchronized:1. 可以锁定方法或代码块,实现互斥和同步。
底层通过监视器锁来实现,性能略差于其他工具。
可实现条件同步。使用场景:需要原子性、互斥性和可见性的同步场景,或者需要使用条件同步的情形。volatile:1. 只能用于修饰变量,实现变量可见性。
不实现互斥性,性能较高。
单次读写的原子性可以保证,但不保证复合操作的原子性。使用场景:只需要保证变量在多线程环境下的可见性,而不需要同步的情形。Atomic:1. 基于CAS实现,不使用锁,实现原子性操作,性能较高。
仅提供了几种基本类型的原子操作,更复杂操作需要自行组合。
不保证可见性,需要配合volatile使用。使用场景:高并发环境下的原子性操作,但不需要同步的情形。对比:1. synchronized实现同步,其他两个只实现轻量级同步。
synchronized可实现条件同步,其他不行。
volatile只实现可见性,其他都实现原子性。
Atomic性能最高,synchronized最低。所以,三种工具各有优势,根据实际需要选择适当的同步手段,也可以配合使用,实现强大的同步功能。94. Java 8新增的新的日期时间API有哪些?

Java 8中新增的日期时间API主要在java.time包下,主要有:1. LocalDate:只包含日期的对象。

LocalTime:只包含时间的对象。
LocalDateTime:包含日期和时间的对象。
Instant:表示时间线上的一个点,精度为纳秒。
Duration:用于计算两个“时间”之间的间隔。
Period:用于计算两个“日期”之间的间隔。
ZonedDateTime:带时区的日期时间对象。
ZoneId:时区对象。这些新的日期时间API主要有以下优点:1. 线程安全:新API是不可变且线程安全的。
clearer:API清晰易用,方法 names 很贴近实际用途。
包括时间和日期:之前的java.util.Date类只包含日期和时间,Java 8 提供单独的 LocalDate, LocalTime, LocalDateTime 类。
时区支持:提供了丰富的时区支持,内置很多 Support 时区,也支持自定义时区。
校正处理:能够更加优雅地处理时间间隔和时区。
其他:还提供了其他注解如 @DateTimeFormat,新的格式化工具类等。常用方法示例:

// 获取当前时间
LocalDateTime now = LocalDateTime.now(); // 指定参数创建对象
LocalDate date = LocalDate.of(2020, 1, 1);
LocalTime time = LocalTime.of(12, 12, 12);// 获取各个部分
LocalDateTime.now().getYear();
LocalDateTime.now().getMonth();
LocalDateTime.now().getDayOfMonth();
LocalDateTime.now().getHour();// 日期转换 
 LocalDate date = LocalDate.now(); 
 String strDate = date.format(DateTimeFormatter.ISO_LOCAL_DATE); 
 LocalDate date2 = LocalDate 

parse(strDate, DateTimeFormatter.ISO_LOCAL_DATE); // 日期增加/减少 
LocalDate date = LocalDate.now(); 
date = date.plusDays(1); 
date = date.plusWeeks(1); 
date = date.plusMonths(1); 
date = date.plusYears(1); // 两个日期相减 
Period period = LocalDate.now().minus(LocalDate.of(2020, 1, 1)); 
System.out.println(period.getYears()); 
System.out.println(period.getMonths()); 
System.out.println(period.getDays()); // Instant 时间戳
Instant timestamp = Instant.now(); 
System.out.println(timestamp.toEpochMilli());// 时区 
ZoneId shanghaiZone = ZoneId.of("Asia/Shanghai"); 
ZonedDateTime zdt = ZonedDateTime.now(shanghaiZone); 
System.out.println(zdt.getYear());
System.out.println(zdt.getMonth());
System.out.println(zdt.getDayOfMonth()); 
System.out.println(zdt.getHour()); 
System.out.println(zdt.getMinute());
System.out.println(zdt.getSecond());

所以总结来说,Java 8新增的日期时间API提供了丰富的功能来操作日期、时间和时区,使用清晰方便,同时也解决了以前版本API的缺陷,是日期时间编程的不错选择。

Optional类的主要方法有哪些?
Optional类主要用于避免NullPointerException,主要方法有:


1. Optional.empty():创建一个空的Optional实例。

2. Optional.of(value):创建一个包含value值的Optional实例,value不能为null。

3. Optional.ofNullable(value):创建一个Optional实例,如果value为null,则返回empty(),否则返回of(value)。

4. isPresent():判断Optional实例是否包含值,包含则返回true,否则返回false。

5. get():获取Optional实例的值,如果调用empty()的get(),会抛出NoSuchElementException。

6. orElse(defaultValue):获取Optional实例的值,如果为空则返回defaultValue。

7. orElseGet(Supplier):和orElse()类似,但是可以接受一个lambda表达式或方法来生成默认值。

8. map(Function):如果Optional实例有值,则对其执行Function函数转换并返回Optional。否则返回Optional.empty()。

9. flatMap(Function):和map()类似,但是Function返回值必须是Optional,并会对其再执行flatten().

10. ifPresent(Consumer):如果Optional实例有值,则执行Consumer的accept方法。

11. filter(Predicate):如果Optional实例有值且值匹配Predicate,则返回该Optional,否则返回Optional.empty()。

示例代码:
```java
// 创建空Optional实例
Optional empty = Optional.empty();

// 创建非空Optional实例 
Optional name = Optional.of("Jone");

// orElse获取值或默认值
String name2 = name.orElse("jack");

// orElseGet同上,使用Supplier
String name3 = name.orElseGet(() -> "jack");  

// map
Optional upperName = name.map(value -> value.toUpperCase());  

// flatMap
Optional upperName = name.flatMap(value -> Optional.of(value.toUpperCase()));  

// ifPresent
name.ifPresent(value -> System.out.println(value));  

// filter
Optional longName = name.filter(value -> value.length() > 5);

所以Optional类主要用于避免空指针异常,提供了一系列方法来方便对空值进行处理,是Java 8中引入的一个很有用的新特性。

Stream API的主要方法有哪些?

Stream API是Java 8中对集合操作的增强,主要方法有:1. forEach:迭代流中的每个数据。2. distinct:去除重复元素。3. filter:过滤元素。4. map:映射每个元素转换为其他形式。5. flatMap:把 Stream 展开成一个更加扁平的流。6. limit:限制流大小。7. skip:跳过元素。 8. peek:中间操作,用于调试。9. sorted:排序流中的元素。10. anyMatch:检查是否至少有一个元素匹配给定的 Predicate。11. allMatch:检查是否流中所有元素都匹配给定的 Predicate。12. noneMatch:检查是否流中没有元素匹配给定的 Predicate。13. findAny:返回流中的任意一个元素。14. findFirst:返回流中的第一个元素。15. collect:收集流中的元素。16. reduce:通过指定的统计函数聚合流中的元素。17. count:返回流中元素的总个数。18. max:返回流中最大值元素。19. min:返回流中最小值元素。示例代码:

java
// forEach
list.stream().forEach(element -> System.out.println(element));  

// filter
list.stream().filter(element -> element > 5).forEach(System.out::println);

// map
list.stream().map(element -> element * 2).forEach(System.out::println);  

// flatMap  
List> lists = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4));
lists.stream().flatMap(list -> list.stream()).forEach(System.out::println);

// limit和skip  
list.stream().skip(3).limit(2).forEach(System.out::println);

// anyMatch和allMatch
boolean anyMatch = list.stream().anyMatch(element -> element > 5);  
boolean allMatch = list.stream().allMatch(element -> element > 0);

// reduce  
Integer sum = list.stream().reduce(0, (a, b) -> a + b);

// max和min  
Optional max = list.stream().max(Integer::compareTo);  
Optional min = list.stream().min(Integer::compareTo);

Stream API提供了对集合功能的增强,让我们可以更加方便地对集合进行各种操作,是Java 8中引入的一个比较重要的特性。

Stream API的主要方法有哪些?

java
// forEach
list.stream().forEach(element -> System.out.println(element));  

// filter
list.stream().filter(element -> element > 5).forEach(System.out::println);

// map
list.stream().map(element -> element * 2).forEach(System.out::println);  

// flatMap  
List> lists = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4));
lists.stream().flatMap(list -> list.stream()).forEach(System.out::println);

// limit和skip  
list.stream().skip(3).limit(2).forEach(System.out::println);

// anyMatch和allMatch
boolean anyMatch = list.stream().anyMatch(element -> element > 5);  
boolean allMatch = list.stream().allMatch(element -> element > 0);

// reduce  
Integer sum = list.stream().reduce(0, (a, b) -> a + b);

// max和min  
Optional max = list.stream().max(Integer::compareTo);  
Optional min = list.stream().min(Integer::compareTo);

Stream API提供了对集合功能的增强,让我们可以更加方便地对集合进行各种操作,是Java 8中引入的一个比较重要的特性。

Lambda表达式的主要特征是什么?

Lambda表达式是Java 8中引入的一个重要特性,主要特征有:1. 无类型:不需要指定参数类型,编译器可以从上下文推断出参数类型。2. 简洁:没有声明语句,仅需关注方法体。3. 可重用:Lambda表达式可以被当成参数传递。4. 可变参数:Lambda表达式可以声明可变参数。5. 隐式返回值:如果Lambda表达式中的方法体只有一条语句,可以不用使用return关键字。语法格式:

(参数) -> {方法体}

或简化为:

参数 -> 方法体

示例:

java
// 无参数无返回值
() -> System.out.println("Hello");  

// 单参数无返回值 
x -> System.out.println(x);  

// 有两个参数有返回值
(x, y) -> x + y;  

// 可变参数
(x, y, z) -> {
    System.out.println(x);
    System.out.println(y);
    System.out.println(z);
}

// 单参数隐式返回值 
x -> x + 1;

所以Lambda表达式使Java具有函数式编程的特性,让代码更简洁紧凑,是Java 8中引入的一个重要特性。但是Lambda表达式也使得Java的类型系统变得更加复杂,需要理解目标类型、上下文推断等概念,需要一定时间去适应。

Java 8中接口新增的默认方法和静态方法是什么?
在Java 8中,接口新增了默认方法和静态方法:默认方法:1. 使用default关键字标注。
为接口中的方法提供了默认实现。
实现类可以重写默认方法,也可以直接使用。
减少了版本发生变化时对实现类的影响。静态方法:1. 使用static关键字标注。
可以通过接口直接调用,无需实现类对象。
实现类不能重写静态方法。
主要用于接口中添加工具方法。示例:

java
public interface Hello {
    // 默认方法
    default void sayHello() {
        System.out.println("Hello!"); 
    }

    // 静态方法
    static void sayHello(String name) {
        System.out.println("Hello " + name + "!"); 
    }
}

public class HelloImpl implements Hello {

} 

Hello.sayHello("John"); // Hello John!

HelloImpl hello = new HelloImpl();
hello.sayHello(); // Hello!

所以接口的这两个新增特性给Java带来了更多灵活性,主要目的是:1. 向后兼容,添加新方法而不影响实现类。

防止API的滥用和过度设计。
让接口具有多个角色。默认方法和静态方法都属于可选方法,实现类可以选择直接使用或重写。这使得接口的作用不再是简单的定义契约,更加灵活和强大。
如何对数组进行并行处理?

在Java 8中,可以通过Arrays的并行处理方法来并行处理数组,主要有:1. parallelSort():并行排序。

parallelSetAll():并行设置数组元素。
parallelPrefix():并行计算数组前缀。
parallelStream():返回数组的并行流。这些方法可以利用多核CPU实现并行计算,加速数组的处理速度。示例代码:

java
// 并行排序
Integer[] nums = {6, 9, 1, 4, 2, 10, 3};
Arrays.parallelSort(nums);
for (int i : nums) {
    System.out.println(i);  
}
// 1 2 3 4 6 9 10

// 并行设置数组元素 
Integer[] nums = new Integer[10];
Arrays.parallelSetAll(nums, index -> index * 2);
for (int i : nums) {
    System.out.println(i);
}
// 0 2 4 6 8 10 12 14 16 18

// 并行计算数组前缀 
Integer[] nums = {1, 2, 3, 4, 5}; 
long sum = Arrays.parallelPrefix(nums, (a, b) -> a + b); 
System.out.println(sum);  // 15

// 返回数组并行流
Arrays.asList(nums).parallelStream().forEach(System.out::println);

并行排序和设置数组元素会直接修改原数组,并行前缀会返回计算结果,并行流则可以用于后续的各种并行计算。需要注意的点:1. 数组的长度要足够大,才能利用并行带来的性能提升。

任务需要足够耗时,否则并行所带来的调度开销会超过性能提升。
函数需要是并行友好的,没有数据依赖或副作用。
硬件环境需要有多核CPU。所以arrays的这些并行方法可以利用多核CPU提高数组处理的性能,但是需要注意数组长度、任务时间以及函数特征等条件,才能达到并行加速的效果。对于小数组或简单任务,使用并行反而会降低性能,需要根据实际情况选择。

100.Comparator和Comparable的区别是什么?

Comparator和Comparable都是用于排序和比较的接口,主要区别是:Comparable:1. 用于对象的默认排序,通过实现compareTo()方法来定义对象的自然排序。

一个类只能有一个Comparable的实现,因为只能有一种自然排序。
不灵活,算法实现在compareTo()中,不能独立出来。
需要修改被比较对象的类来实现Comparable接口。Comparator:1. 用于对象的定制排序,通过实现compare()方法来定义排序算法。
一个类可以有多个Comparator的实现,所以排序算法可以重用。
灵活,可以将算法实现在不同的Comparator中独立出来。
不需要修改被比较对象的类来实现Comparator接口。总结:1. Comparable代表对象的自然排序,Comparator代表定制排序。
一个类只能有一个Comparable,但可以有多个Comparator。
Comparable由被比较对象实现,Comparator由第三方实现。
Comparable排序算法不灵活,Comparator排序算法灵活。示例代码:

java
public class Person implements Comparable {
    private int age;
    public Person(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Person o) {
        return age - o.age; 
    }
}

Arrays.sort(persons); // 使用Comparable排序

Comparator comparator = (p1, p2) -> p2.age - p1.age;
Arrays.sort(persons, comparator); // 使用Comparator排序

Java 9的新特性有哪些?

Java 9的主要新特性有:1. 模块系统(Project Jigsaw):将JDK内部的包重新组织成93个模块,模块间有严格的访问规则,可以在编译和运行时检查及强制实施。2. 进程API(JEP 102):提供了一个进程级的API,用来管理和控制操作系统进程。3. 弃用的API检测(JEP 277):可以在编译时检测对已过时API的调用,鼓励迁移到新增的API。4. 安全增强:撤销不安全的加密标准、加强Kerberos等。 5. JShell:添加了一个基于REPL的交互式SHELL工具,可以直接输入声明、表达式、语句等,实时获得反馈。6. 集合工厂方法:List.of(), Set.of(), Map.of() 等返回不可变集合,更简洁。7. 私有接口方法:在接口中添加私有方法,只有接口的实现类才能访问私有方法。8. 钻石操作符的改进:允许在匿名类中使用钻石操作符 <>。 9. Stream API的改进:添加TakeWhile、DropWhile、Iterate等方法。10. 新的版本字符串:新增Version类来处理软件版本信息。11. 其他:标记的泛型实例化(JEP 301)、 javadoc的HTML 5支持、免除栈轨迹检测等。示例代码:

java
// 模块
module com.example.app {
   requires com.example.lib;
}

// 集合工厂方法
List list = List.of("a", "b", "c");

// 私有接口方法
interface Hello {
    private void greet() {
        System.out.println("Greetings!"); 
    }  
}

// Stream改进  
Stream.iterate(0, i -> i + 1).takeWhile(x -> x < 10).forEach(System.out::println);

// 版本字符串
Version v9 = Version.parse("9"); 
Version v1_9 = Version.parse("1.9");

所以 Java 9 对Java语言本身进行了很多改进,增加了许多新特性来帮助开发者构建健壮、安全和高性能的应用程序。模块系统的引入是此版本的重点,未来几年会大大影响Java软件的架构和发布。

Java 10的新特性有哪些?

Java 10的主要新特性有:1. 局部变量类型推断(Local-Variable Type Inference):在定义局部变量时可以不指定类型,让编译器推断类型。使用var关键字,以前是不允许的。 2. 并行全垃圾回收(Parallel Full GC):将串行的Full GC转换为并行版本,可以显著缩短堆内存回收停顿时间。3. 应用程序类数据共享(App CDS):将JDK里的类数据与应用程序的类数据合并为一个可以在多个JVM之间共享的文件,从而提高应用启动速度。4. 线程本地握手(Thread-Local Handshakes ):添加一套API来协调多个线程之间的执行,不需要使用wait/notify等方法。5. 增强var处理(Enhanced @var Processing): var关键字现在可以用于lambda表达式参数,catch语句参数以及泛型方法参数等。6. 未处理异常的改进(Improved Unhandled Exception Reporting):默认情况下会打印更详细的未处理异常的调用堆栈信息。 7. 标准HTTP客户端(Standard HTTP Client):从JDK 11开始,HttpURLConnection将被弃用,标准HTTP客户端将取而代之。8. 移除废弃的API(Removal of Deprecated API):例如移除 '#' 作为注释符等。除此之外,还有Pattern Matching(预览)、 Parallel Full GC for G1、 Application Data Sharing等特性。示例代码:

java 
// 局部变量类型推断
var name = "John"; 

// 线程本地握手
ThreadLocal tl = ThreadLocal.withInitial(() -> 1);
tl.set(2); 
var v = tl.get(); // v为int类型

// 增强var
Predicate p = var x -> true;  
Consumer c = var x -> {};

// 标准HTTP客户端  
HttpRequest request = HttpRequest.newBuilder()
                                .uri(URI.create("https://example.com/"))  
                                .GET()  
                                .build();
HttpResponse response = HttpClient.newHttpClient()
                                        .send(request, HttpResponse.BodyHandlers.ofString());

所以Java 10在Java 9的基础上推出了一些新的特性,进一步增强了局部变量类型推断、并行与性能、标准库、废弃API移除等方面,但是相比Java 9来说影响较小。由于模块系统引入,未来几年的变动会较小,主要是在优化和完善各项新特性。

Java 11的新特性有哪些?

Java 11的主要新特性有:1. ZGC:ZGC是一种全新的垃圾回收器,主要面向超大内存(>10GB)的系统,使用“region”的概念来实现更高并发且低停顿的GC。2. Epsilon:移除JDK里几乎所有的模块,只包含Java语言的核心模块java.base。用于微型环境下的Java应用。3. 变量语义版本(Version Semantics):版本字符串遵循语义版本规则major.minor.patch,由此可以准确判断一个版本与另一个版本的兼容性。4. 局部变量语法糖(Local-Variable Syntax for Lambda Parameters):允许使用var来代表lambda表达式参数类型。5. 新增HttpClient:标准HTTP客户端从JDK 9的incubator模块转至JDK 11的主模块,取代HttpURLConnection。6. 字符串新增方法(New Methods in String):lines(), strip(), stripLeading(), stripTrailing(), repeat()等。7. 增强var(Extended var Usage):var现在可以用于记录组件的初始化语句以及增强for循环的语句等处。8. 增强的安全性(Security):TLS 1.3, ECC, EdDSA等加密算法和协议更新,CTS移除等。9. 其他:单个源文件可以包含多个模块声明、ZGC可以管理非堆内存、桌面应用支持从模块路径加载DLL等。示例代码:

java
// ZGC  
int size = 1024 * 1024 * 15; // 15MB
byte[] buffer = new byte[size]; 

// Epsilon
// 没有任何java代码,只包含一个Metainf文件夹

// 变量语义版本  
Version v11 = Version.parse("11.0.1");  

// 局部变量语法糖
(var x, var y) -> x + y;  

// 字符串方法
"  Hello  ".strip();      // "Hello"
"abc".repeat(3);         // "abcabcabc"

// var增强
var obj = new Object() { @Override public String toString() { return "hello"; } };
var list = new ArrayList() {{ add("a"); add("b"); }}; 
for (var str : list) {}

所以Java 11做为长期支持版本,在稳定性、兼容性和安全性方面有较大提高,同时也在JDK自身引入了许多新特性,为未来版本打下基础。这也是目前最常用的Java LTS版本。

Java 12的新特性有哪些?

Java 12的主要新特性有:1. Shenandoah GC:一种低暂停时间的垃圾回收器,使用“标记-复制”算法来实现GC,目标暂停时间可以达到10ms以内。2. Microbenchmark Suite:一个用来评测JDK中微基准测试的框架,可以用来评测JDK的性能,找到热点和反馈优化的区域。3. Switch表达式(Preview):允许在switch语句中使用yield关键字,将switch转换为表达式。4. 文本块(Preview):使用"""来定义多行字符串,可以在字符串内直接使用回车和换行。5. NumberFormat扩展:新增格式化十六进制浮点数和二进制整数的功能。 6. FileSystems.getDefault():获取默认文件系统的静态工厂方法。7. CompletedFuture:一个已完成的Future,直接get()会得到一个值,主要用于返回已计算好的值。 8. 安全增强:TLS 1.3支持完善,CTS移除, chaCha20和Poly1305加密算法支持等。9. 其他:提高Jar文件启动速度,Unicode 11支持,Socket和ServerSocket支持选项“SO_REUSEPORT” 等。示例代码:

java  
// Switch表达式
int result = switch (color) {  
    case "red" -> 1;  
    case "blue" -> 2;  
    default -> 0;  
};  

// 文本块
String html = """
        
            
                Hello, world
            
        
        """;

// NumberFormat  
NumberFormat.getFloatInstance().formatHex(12.34f); // 3.1eb851eb851ecp1  
NumberFormat.getIntegerInstance().formatBinary(15); // 1111  

// CompletedFuture
CompletableFuture future = CompletableFuture.completedFuture("Hello");
future.get(); // Hello

// 安全增强   
HttpsURLConnection con = (HttpsURLConnection)url.openConnection();
con.setRequestProperty("TLS", "TLSv1.3");

所以Java 12在Java 11的基础上做了一定改进,引入了几个新的预览特性,提高了JDK在性能、安全和国际化等方面的支持,但是相比11版本而言改动较小。Java 12属于短期支持版本,在2020年关闭更新维护,建议项目使用长期支持版本11和未来的17版本。

Java 13的新特性有哪些?

Java 13的主要新特性有:1. 文本块(Text Blocks):"""可以定义多行字符串,并保留字符串内的空格、换行等格式。(从Preview升级为正式特性) 2. 新的socket API(Socket API Updates):StandardSocketOptions枚举新增TCP_KEEPIDLE、TCP_KEEPINTVL和TCP_KEEPCNT选项。ServerSocket的构造方法新增可选的SocketAddress参数。3. 动态CDS归档(Dynamic CDS Archives):应用程序类数据可以在运行时动态生成和加载,不再需要提前静态生成。4. NullPointerExceptions消息增强(NullPointerException Messages):空指针异常信息中包含变量名称及其类型,方便定位问题。5. 重新实现System.arraycopy():用更现代的方式重写该方法,提供更好的性能。6. 移除废弃的GC组合(Remove the Deprecated GC Combinations):移除了一些GC算法的过时组合,例如ParallelOld+CMS。7. 新增实例of Pattern Matching(Pattern Matching for instanceof):instanceof关键字右侧可以使用变量,如果判断为true,则变量值绑定到对象引用上。 8. 其他:增强var使用范围,Records为正式特性等。示例代码:

java
// 文本块
String sql = """
        SELECT * 
        FROM users 
        WHERE age > 30
        """;

// Socket API    
ServerSocket serverSocket = new ServerSocket(8000, 10, 
       new InetSocketAddress("127.0.0.1", 9000)); 

// NullPointerExceptions消息增强  
String str = null;
str.length(); // NullPointerException: Cannot read the length of null (str)  

// 重新实现System.arraycopy()
System.arraycopy(src, 0, dest, 0, length);  

// 新的实例of  
if (obj instanceof String str) {
    System.out.println(str.toUpperCase());  
}

所以Java 13对文本块、Socket API、实例of表达式等做了一定改进,提高了null检查和系统arraycopy方法的友好性,移除了一些过时内容。但是总体来说,相比12版本改动并不算太大。

Java 13属于短期支持版本,在2021年关闭更新维护,目前生产环境更推荐使用长期支持版本11和17。Java的发展似乎进入了比较稳定的阶段,未来每个版本的改动可能会逐渐减小。模块化、预览特性和兼容性会是关键的考量因素。新的语法特性会在preview状态下先行试用,以吸收更多反馈后再正式发布。（已编辑）

什么是JVM?它的作用是什么?
JVM全称为Java Virtual Machine,它是Java的运行环境,负责运行Java程序。它的作用是:1. 执行Java程序,通过读取Java文件中的字节码指令来运行程序。
为Java程序提供运行环境,屏蔽底层系统的差异。Java程序在不同平台运行主要依靠JVM。
实现垃圾回收,自动管理内存的分配和释放。
实现安全管理,确保Java程序在运行时不会造成危害。
提供丰富的编程库,支持网络、文件、GUI等操作。所以JVM作为Java语言的基石,它允许Java程序在不同的硬件平台和操作系统上运行,实现了Java程序的跨平台特性。除了执行引擎的功能,JVM还提供了自动内存管理、安全管理以及丰富的运行环境,这些都提高了Java作为一门语言的吸引力。理解JVM的工作原理和架构对学习Java至关重要。107. JVM的主要组成结构有哪些?

JVM的主要组成结构包括:1. 类加载器(ClassLoader):负责加载Java类到内存中,包括加载类的二进制数据、将其解析为一个个 Java 类(Class 文件对象),然后在堆内存中生成这些Class对象。2. 运行时数据区:用于存放Java程序在运行过程中的各种数据,包括方法区、堆区、栈区、本地方法栈区、寄存器等。3. 垃圾收集器(GC):负责监视和回收Java堆内存中不再使用的对象,回收被占用的内存空间。4. 执行引擎:负责执行Java程序的字节码,并在遇到方法调用等事件时调用各个功能模块。5. 命令行接口:负责接收用户输入的命令并作出相应的响应。如运行Java程序时可以设置JVM参数。6. 本地接口:是JVM与本地系统交互的接口,用于访问本地系统的资源。 7. 安全管理器:按照Java语言的安全策略管理代码访问资源的权限。8. 反射机制:允许运行中的Java程序获取自身的信息并操作。9. 对象_$(Monitor):用于锁定在同一时间最多只有一个线程执行的代码区域(方法/同步块)。10. 其他:字符串常量池、PC寄存器、异常处理等。所以JVM的架构相当复杂,上面提到的各个组成部分相互协作,来达到执行Java程序、运行环境管理的目的。

类加载器(ClassLoader)有什么作用?

类加载器的主要作用是:1. 加载类的二进制数据:读取Java类的.class文件到内存。2. 将二进制数据解析为Java类对象:将二进制数据解析成Class对象,包含类的结构、字段、方法等信息。3. 将Class对象放入方法区:将解析得到的Class对象存放到方法区,方便程序第二次引用该类时直接使用。4. 遵循委托模型:类加载器按照父子关系组织成一个有向树结构,子加载器首先委托父加载器去加载类,直到某个加载器可以完成类加载。这保证所有加载器得到的类都是同一个版本。5. 实现类的隔离:通过委托模型,可以在同一个JVM中隔离不同的类,允许相同名字的类的多个版本同时存在。JVM主要提供三种类加载器:1. 启动类加载器(Bootstrap ClassLoader):负责加载Java核心库,由C++实现,是QS老祖宗。2. 扩展类加载器(Extension ClassLoader):负责加载Java的扩展库,默认由sun.misc.Launcher$ExtClassLoader实现。3. 系统类加载器(System ClassLoader):负责加载classpath目录下的类与jar,默认由sun.misc.Launcher$AppClassLoader实现。4. 用户自定义类加载器(User Customized ClassLoader):可以自定义类加载逻辑,一般继承ClassLoader来实现。所以类加载器起着连接Java代码与JVM的重要作用,不同的加载器可以实现类的隔离与相互加载覆盖,满足复杂的需求。但继承性与委托规则需要遵循,防止出现类的不一致。理解Java的类加载机制对解决实际问题大有裨益。示例:

java
// 自定义类加载器
public class MyClassLoader extends ClassLoader {
  // 实现findClass方法
  protected Class findClass(String name) throws ClassNotFoundException {
    // 自定义类加载逻辑...
  }
}

运行时数据区有哪些?它们的作用分别是什么?

JVM运行时数据区主要包括:1. 方法区(Method Area):用于存储类信息(类元数据)、常量、静态变量等数据。对应于JDK1.6之前的永久代,JDK1.7后改为元空间。2. 堆区(Heap Area):用于存储对象实例以及数组等。是GC的主要区域,无序,回收效率较低。3. 栈区(Stack Area):用于存储局部变量,方法参数等。有顺序,非GC回收区域。按照栈结构LIFO入栈和出栈。4. 本地方法栈区(Native Method Stack Area):与栈区相似, 用于存储native方法的信息。5. 程序计数器(Program Counter):记录当前线程执行的字节码行号,支持线程去断电续传。6. 直接内存区(Direct Memory):I/O设备的内存映射区域,用于加速I/O读写操作。可以直接访问堆外的内存。其中,堆区和方法区是最大的两个区域,也是GC的主要调整区域。栈区和本地方法区随线程生命周期自动回收,其他几个区域更小。所以运行时数据区为Java程序提供了运行过程中各种数据的存储区域,具有不同的内存分配方式和回收策略。理解不同区域的数据交互与GC机制,有助于我们编写高效的程序和解决实际问题。示例:

java
// 堆区
Student st = new Student();

// 方法区  
Integer num = 10; // 整数常量池

// 栈区
int age = 20;

这（已编辑）

堆区与栈区的主要区别是什么?堆区与栈区的主要区别是:1. 堆区由GC主管,栈区由虚拟机自动释放。堆区需要手动释放对象以避免内存泄漏,栈区随着方法结束自动释放。2. 堆区内存随着对象创建不断增加,栈区内存根据方法调用创建和销毁。堆区无穷大,栈区仅1MB左右。3. 堆区对象存活时间较长,栈区一般仅方法运行过程。4. 堆区分配内存使用new关键字,栈区分配内存随方法调用自动分配和释放。5. 堆区内存空间连续,栈区内存空间上下文相关联。所以简单来说:堆区:主要存放对象实例,回收由GC完成。空间广,对象生命周期长。
栈区:主要存放方法运行信息,回收由虚拟机自动完成。空间小,对象生命周期短。理解堆栈区的区别有助于我们合理使用内存,编写高效程序。大对象放入堆区,方法运行信息放入栈区,避免内存泄漏等。示例:

java
// 堆区
public class Person {
  public String name;

  public Person(String name) {
    this.name = name;
  }
}

Person p = new Person("John"); // 在堆区创建对象

// 栈区
public void calculate() {
  int a = 10; // 栈区
  int b = 20; // 栈区
}

那么a和b变量仅在calculate方法运行期间存在,方法结束后自动释放。而p对象在堆区持续存在,直到没有任何引用指向,才会被GC回收。111. Java的垃圾收集机制是什么?常见的GC算法有哪些?Java的垃圾收集机制是:自动内存管理机制,回收不再使用的对象,释放所占用的内存空间。其主要作用是:1. 回收不再使用的对象,防止过度分配内存造成内存泄漏。

释放对象占用的内存空间,提高内存的利用率。
整理内存碎片,提高内存分配效率。Java常见的GC算法主要有:1. 标记-清除(Mark-Sweep):分标记和清除两阶段,效率较低,会产生大量内存碎片。2. 标记-压缩(Mark-Compact):标记阶段同上,然后压缩所有可达对象。效率较高,但是消耗资源大。3. 标记-复制(Mark-Copy):将内存划分为等量的两块,每次使用其中一块。标记后把可达对象复制到另一块上,再清除上一块。分代最常用。4. 分代收集(Generational Collection):根据对象存活周期将内存分为“新生代”和“老年代”,各个代使用不同的GC算法,提高回收效率。5. G1(Garbage First):将堆内存分割成多个大小相同的区块,然后Region内部采用“标记-复制”算法进行回收。可以指定Region回收的顺序。除此之外,还有增量式回收等算法。所以理解不同GC算法的工作原理和适用场景,有助于我们综合考虑对象存活周期等因素,编写高效程序。
什么是GC Roots?

GC Roots是垃圾回收的起始点,指向这些根对象的对象都被视为可达对象,会在垃圾回收阶段被标记。常见的GC Roots有:1. 虚拟机栈(栈帧中的本地变量表)中的引用:当方法执行过程中,会在自己的栈帧中保存对象引用。2. 方法区中的类静态属性引用:静态变量保存着对类中对象的引用。3. 方法区中的常量引用:字符串常量池中也引用着对象。4. JNI(Native方法)中引用的对象:JNI方法 maintain 一个指向JVM对象的全局引用表。 5. 监视器锁定的对象:当一个对象处于同步块中时,会锁定该对象作为锁,此时该对象就是GC Root。6. 本地方法栈中的引用:和虚拟机栈一样,它包含按照最后进先出方式放置的参数和局部变量。7. 线程中引用的对象:Java线程保留着对线程组对象、线程对象及堆栈的引用。这些引用的对象会成为GC Root。所以只要一个对象直接或间接与GC Roots相关联,那么它就不会被垃圾回收机制回收。反之,无法从GC Roots到达的对象都会被判断为垃圾, Subjected to garbage collection。理解GC Roots可以帮助我们分析对象为什么会被回收或逃脱回收,这在解决内存泄漏问题时非常重要。保持对象与GC Roots之间的可达性,是确保对象不会被提前回收的条件。示例:

java
public class GcRootDemo {
  public static void main(String[] args) { 
    Test t1 = new Test(); // 虚拟机栈引用
    Test t2 = Test.staticTest; // 静态变量引用
    String str = "str"; // 常量池引用
    new Thread(new TestThread()).start(); // 线程引用 
  }
}

class TestThread implements Runnable {
  public void run() {
    Test t3 = new Test(); // 线程堆栈引用
  }
}

这里t1-t3对象都与GC Roots相关联,不会被回收。str对象与字符串常量池的引用相关,也会逃脱回收。

Java中的内存泄漏是什么?有哪些常见的原因?

内存泄漏指对象不再被使用,但是没被垃圾回收器回收,造成内存浪费的情况。这会导致程序运行过程中内存使用量不断增大,严重时会OutOfMemory。Java中的常见内存泄漏原因主要有:1. 没有置空或清理集合类中的元素:如果集合类属性中保留了对对象的引用,而没有清理,会导致对象无法回收。2. 没有终止线程:线程保留着线程运行过程中的全部对象引用,如果线程未终止,这些对象都不会被回收,发生内存泄漏。 3. 没有释放I/O资源:文件、数据库连接等资源使用后没有关闭,会一直占用内存导致泄漏。4. 添加监听器但未注销:添加监听器会隐式持有监听器对象的引用,如果未注销,监听器对象会一直存在。5. 静态资源未清理:静态变量会一直持有对象引用,如果未主动置空或回收,会产生泄漏。6. 受保护的反射对象:通过反射获取的对象,需要主动调用close()方法,否则会持有对象引用发生泄漏。 7. JNI局部引用实际漏失:JNI方法中如果没有删除局部引用,它会成为全局引用,持有对象导致泄漏。8. 数据库连接池未关闭:数据库连接池在关闭前都会持有数据库连接对象,需要显式关闭池,否则会有大量连接对象无法回收。所以内存泄漏的根源在于:有对象引用被非GC Root元素持有,导致无法被垃圾回收器回收。修复内存泄漏的方法就是:破坏对象与非GC Root之间的引用链。示例:

java
public class MemoryLeak {
  static Test obj;

  public static void main(String[] args) { 
    obj = new Test(); // 静态资源
  }
} 

// 未清理集合  
List

前言

题目如下：

Java是什么?

😀 开始我们的正题，进行分享面试题，

ヾ(◍°∇°◍)ﾉﾞ

JDK和JRE的区别是什么?

发表回复 取消回复

发表回复取消回复