Java工程师必背面试题(更新中)

置顶 Yuki゛

已于 2024-07-30 19:31:57 修改

阅读量1.6k

点赞数 56

文章标签： java 开发语言面试 java-ee 数据结构 mysql 分布式

于 2024-07-17 16:48:22 首次发布

本文链接：https://blog.csdn.net/Yu2uki/article/details/140499141

版权

一、基础

1.String/StringBuffer/StringBuilder区别

第一点: 可变和适用范围。String对象是不可变的，而StringBuffer和StringBuilder是可变字符序列。每次对String的操作相当于生成一个新的String对象，而对StringBuffer和StringBuilder的操作是对对象本身的操作，而不会生成新的对象，所以对于频繁改变内容的字符串避免使用String，因为频繁的生成对象将会对系统性能产生影响。
第二点: 线程安全。String由于有final修饰，是immutable的，安全性是简单而纯粹的。StringBuilder和StringBuffer的区别在于StringBuilder不保证同步，也就是说如果需要线程安全需要使用StringBuffer，不需要同步的StringBuilder效率更高。
总结：
- 操作少量的数据 = String
- 单线程操作字符串缓冲区下操作大量数据 = StringBuilder
- 多线程操作字符串缓冲区下操作大量数据 = StringBuffer

最简回答：String是不可变的字符串，每次修改都会创建新的对象，适用于不经常修改的字符串操作；StringBuffer是可变的字符串，线程安全，适用于多线程环境；StringBuilder也是可变的字符串，但不是线程安全的，适用于单线程频繁修改字符串的场景。

2.反射机制及主要用到的方法

在 Java 中的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为 Java 语言的反射机制。通过反射机制使我们所写的代码更具有「通用性」和「灵活性」，比如Spring/Spring Boot、MyBatis 等框架大量用到了反射机制。比如类上加上@Component注解，Spring就帮你创建对象，比如约定大于配置。

以下是反射常用到的方法：

1. `Class.forName(String className)`：根据类名获取对应的Class对象。

2. `getClass()`：获取对象的运行时类型。

3. `getMethod(String name, Class<?>... parameterTypes)`：获取指定方法名和参数类型的方法。

4. `getField(String name)`：获取指定名称的字段。

5. `newInstance()`：使用默认的构造函数创建实例。

6. `newInstance(Object... initargs)`：使用指定参数类型和值的构造函数创建实例。

7. `invoke(Object obj, Object... args)`：调用指定对象的方法。

以上只是反射中常用的一些方法，还有其他更多的方法可根据具体需求来使用。反射功能强大，但也要慎用，因为它可能会降低性能，且破坏了面向对象的封装性。在使用反射时应该知道自己的需求，并权衡利弊。

最简回答：Java的反射机制是指在运行时动态地获取类的信息并操作类或对象的能力。通过反射，我们可以在编译时无法确定的情况下，通过类名获取类的实例、获取类的字段、方法、构造函数等信息，并且可以在运行时调用这些方法或访问这些字段。

3.JVM内存结构

运行时数据区域被划分为5个主要组件：

方法区（Method Area）

所有类级别数据将被存储在这里，包括静态变量。每个JVM只有一个方法区，它是一个共享的资源。

堆区（Heap Area）

所有的对象和它们相应的实例变量以及数组将被存储在这里。每个JVM同样只有一个堆区。由于方法区和堆区的内存由多个线程共享，所以存储的数据不是线程安全的。

栈区（Stack Area）

对每个线程会单独创建一个运行时栈。对每个函数呼叫会在栈内存生成一个栈帧(Stack Frame)。所有的局部变量将在栈内存中创建。栈区是线程安全的，因为它不是一个共享资源。栈帧被分为三个子实体：

- 局部变量数组 – 包含多少个与方法相关的局部变量并且相应的值将被存储在这里。
- 操作数栈 – 如果需要执行任何中间操作，操作数栈作为运行时工作区去执行指令。
- 帧数据 – 方法的所有符号都保存在这里。在任意异常的情况下，catch块的信息将会被保存在帧数据里面。
PC寄存器

每个线程都有一个单独的PC寄存器来保存当前执行指令的地址，一旦该指令被执行，pc寄存器会被更新至下条指令的地址。

本地方法栈

本地方法栈保存本地方法信息。对每一个线程，将创建一个单独的本地方法栈。

最简回答：Java的内存结构主要包括方法区、堆、虚拟机栈、本地方法栈和程序计数器。方法区用于存储类信息，堆用于存储对象实例，虚拟机栈用于存储方法调用和局部变量，本地方法栈用于存储非Java方法信息，程序计数器用于记录当前线程执行的指令地址。

4.==与equals区别

区别1. ==是一个运算符 equals是Object类的方法
区别2. 比较时的区别
- 用于基本类型的变量比较时: ==用于比较值是否相等，equals不能直接用于基本数据类型的比较，需要转换为其对应的包装类型。
- 用于引用类型的比较时。==和equals都是比较栈内存中的地址是否相等。相等为true 否则为false。但是通常会重写equals方法去实现对象内容的比较。

最简回答："=="用于比较对象的引用或基本类型的值是否相等，而equals方法用于比较对象的内容是否相等。换句话说，"=="比较的是身份，equals比较的是内容。

5.接口和抽象类的区别

抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final 类型的；
- 接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

最简回答：接口是一种规范，它定义了一组方法的签名，而不包含具体实现。一个类可以实现多个接口。抽象类是一种可以包含具体方法和抽象方法的类，它可以被继承，但不能被实例化。一个类只能继承一个抽象类。简而言之，接口关注的是行为的规范，而抽象类关注的是共享的功能。

6.重写（override）和重载（overload）的区别

重载是指在同一个类或同一个继承结构中的不同类中，存在多个方法具有相同的名称，但它们的参数列表不同（包括参数的个数、类型和顺序）。重载与方法的返回类型和权限修饰符无关，即重载方法可以有不同的返回类型和权限修饰符。重载与继承无关，即重载可以发生在同一个类中，也可以发生在子类对父类方法的重载中。
重写是指子类对父类中的方法提供一个新的实现。为了实现重写，子类中的方法必须满足以下条件：
- 方法名和参数列表必须与父类中的方法完全相同。
- 返回类型必须与父类方法的返回类型兼容，类型相同或者在子类中使用父类方法返回类型的子类型。
- 访问权限不能比父类方法的访问权限更严格。例如，如果父类方法是protected，子类方法不能是private。

最简回答：重写（override）指的是子类重新实现了父类中已有的方法，子类的方法具有相同的名称、参数列表和返回类型兼容。重载（overload）指的是在同一个类中定义了多个方法，它们具有相同的名称但参数列表不同。重写主要涉及继承和多态性，而重载则是在同一个类中的方法之间进行区分。简而言之，重写是对已有方法的重新实现，而重载是创建具有相同名称但不同参数的多个方法。

7.sleep和wait的区别

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

最简回答：sleep是线程休眠一段时间后继续执行，期间保持对象锁不释放；wait是线程等待并释放对象锁，直到其他线程通知后才继续执行。

8.String类的常用方法

length()；返回字符串长度。
getBytes()；返回字符串byte类型数组。
indexof(); 返回指定字符的的索引。
split()；字符串分割，返回分割后的字符串数组。
replace(); 字符串替换。
substring(); 字符串截取。
trim(); 去除字符串两端空格。
toLowerCase(); 将字符串转换为小写字母。
toUpperCase();将字符串转换为大写字母。

9.类加载器加载过程

Java类加载器的加载过程可以分为以下几个步骤：

加载：通过类的全限定名获取字节码文件，并将其转换为方法区内的运行时数据结构。
验证：对字节码进行校验，确保符合Java虚拟机规范。
准备：为类的静态变量分配内存，并设置默认初始值。
解析：将符号引用转换为直接引用，即将类、方法、字段等解析为具体的内存地址。
初始化：执行类的初始化代码，包括静态变量赋值和静态代码块的执行。

10.双亲委派机制

Java双亲委派机制是指在类加载过程中，类加载器会按照一定的顺序委派给父类加载器来尝试加载类。这个机制可以确保类的加载安全和防止类的重复加载。下面是一个简要解答核心知识的通过Java双亲委派机制，可以实现类加载的安全性和避免重复加载，同时也允许开发者自定义ClassLoader来实现特定需求的类加载行为。

最简回答：双亲委派机制是指类加载器在加载类时，首先将加载请求委托给父类加载器，只有当父类加载器无法加载时，才自己尝试加载。从而确保类的加载安全和防止类的重复加载。

11.JVM的GC垃圾回收机制

JVM的垃圾回收（Garbage Collection）机制是自动管理内存的一种机制，它可以识别和回收不再使用的对象，释放其占用的内存空间。以下是垃圾回收机制的介绍以及一些常见的垃圾回收算法：

垃圾回收机制介绍：
- 垃圾回收器负责自动检测和回收不再使用的对象。
- 它通过标记-清除、复制、标记-整理等算法来回收垃圾对象。
- 垃圾回收过程包括标记、清除、整理和压缩等阶段。
常见的垃圾回收算法：
- 标记-清除算法（Mark and Sweep）：首先标记出所有活动对象，然后清除未标记的对象。
- 复制算法（Copying）：将可用内存分为两块，每次只使用其中一块，将存活对象复制到另一块中，然后清除当前使用的块。
- 标记-整理算法（Mark and Compact）：标记出所有活动对象，然后将活动对象向一端移动，之后清理边界外的内存。
- 分代收集算法（Generational Collection）：将堆内存分为新生代和老年代，并使用不同的回收算法。新生代通常使用复制算法，老年代使用标记-清除或标记-整理算法。
默认的垃圾回收算法：
- 默认情况下，HotSpot JVM使用分代收集算法。
- 新生代使用复制算法，其中的Eden区和Survivor区各占一部分，并且采用了对象晋升机制。
- 老年代使用标记-清除或标记-整理算法来回收内存。

最简回答：GC垃圾回收机制是指Java虚拟机自动管理内存的机制，通过自动识别和回收不再使用的对象，释放对应的内存资源，以避免内存泄漏和提高程序性能。

12.JVM如何调优（调优参数）

一般调优，通常优先对堆内存空间进行调整，-Xms表示初始堆内存大小（默认为物理内存的1/64），-Xmx表示最大分配对内存大小（默认为物理内存的1/4）

举例，物理内存4G，运行JAR包时可指定堆内存参数：

java -Xmx3.2g -Xms1g -jar xxx.jar

13.项目是否出现过OOM问题？怎么排查的？可能原因?如何复现一个内存溢出场景？内存溢出和内存泄露的区别？

项目中的内存溢出出现过，是比较常见的问题。
如何排查OOM问题？对于OOM问题的排查，可以采取以下步骤：
- 检查日志文件：查看错误日志或异常信息，定位到具体的异常堆栈信息。
- 使用内存分析工具：如Java的jmap、jstack、VisualVM等工具，分析内存快照以定位内存泄漏。
- 进行代码审查：检查可能引起内存泄漏的代码，如长时间持有对象、未关闭资源等。
- 增加日志和监控：使用合适的日志和监控工具，记录系统的内存使用情况及峰值。
可能的原因：
- 对象过多：创建了大量对象并占用了大量内存。
- 内存泄漏：某些对象被错误地保持引用，使得其无法被垃圾回收器回收。
- 不合理的内存设置：如分配给应用程序的内存不足导致OOM。
如何复现一个内存溢出场景？复现内存溢出的场景可以通过以下方法：
- 增加测试数据量：模拟大量数据的输入，使得应用程序需要占用更多的内存。
- 重复执行某些操作：如循环读取文件或者对对象进行不断修改等。
- 设置小的堆大小：通过设置较小的堆大小，可以更容易地触发OOM异常。
内存溢出和内存泄露的区别：
- 内存溢出：指应用程序在申请内存时，无法获得足够的内存空间，造成异常终止。常见原因是使用了过多的对象并且没有妥善释放。
- 内存泄漏：指应用程序中存在无用的对象占用内存，并且这些对象无法被垃圾回收器回收。随着时间的推移，内存资源逐渐耗尽，最终导致内存溢出

14.JDK1.8的新特性

以下是除去CompletableFuture、重复注解和接口默认方法之外的JDK 1.8的新特性，并附上一些参考代码案例：

1. Lambda表达式：Lambda允许在Java中更简洁地使用函数式编程风格。它提供了一种简洁的方式来表示匿名函数，并使代码更易读、易写。

   // 使用Lambda表达式实现Runnable接口
   Runnable runnable = () -> System.out.println("Hello, Lambda!");
   new Thread(runnable).start();

2. Stream API：Stream API提供了一种用于处理集合和数组的声明性编程模型。它使得可以更直观地操作数据集合，如过滤、映射、排序等操作。

   // 使用Stream API过滤集合中的元素
   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
   List<Integer> evenNumbers = numbers.stream()
                                       .filter(n -> n % 2 == 0)
                                       .collect(Collectors.toList());
   System.out.println(evenNumbers);  // 输出：[2, 4]

3. 新的日期与时间API：JDK 1.8引入了全新的日期和时间API（java.time包）。它提供了更好的处理日期、时间和时间间隔的方式，并且修复了旧API中存在的许多问题。

   // 使用新的日期与时间API获取当前日期
   LocalDate currentDate = LocalDate.now();
   System.out.println(currentDate);  // 输出当前日期（例如：2023-07-21）

4. 方法引用：方法引用允许通过方法的名称来引用已存在的方法。这种方式常用于Lambda表达式中，使得代码更简洁、易读。

   // 使用方法引用调用静态方法
   List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
   names.forEach(System.out::println);  // 输出列表中的每个元素

这些示例代码展示了JDK 1.8中的一些新特性的使用。这只是一部分特性，还有更多特性可供探索和学习。

15.Error和Exception的区别

区别	Error	Exception
来源	来自JVM和系统级别的问题	来自程序执行过程中的异常情况
处理方式	通常无法通过代码处理，程序应该终止	可以通过代码捕获并处理
是否可恢复	通常不可恢复，例如内存溢出等	可能通过代码处理并继续执行
继承关系	继承自java.lang.Error类	继承自java.lang.Exception类
示例	OutOfMemoryError, StackOverflowError	NullPointerException, IOException

最简回答：Error是由系统和JVM引起的严重问题，通常无法通过代码处理，程序应该终止。Exception是由程序执行过程中的异常情况引起，可以通过代码捕获并处理，有可能继续执行。Error继承自java.lang.Error类，而Exception继承自java.lang.Exception类。

二、集合

1.Java常用的集合、分类、涉及到的接口

Collection接口： Collection 是集合 List、 Set、 Queue 的最基本的接口。
- List（列表）：按照元素插入的顺序保存元素，允许重复元素。常见的有ArrayList、LinkedList等。
- Set（集合）：不允许重复元素的无序集合。常见的有HashSet、TreeSet等。
- Queue（队列）：按照先进先出（FIFO）的原则进行元素操作的集合。常见的有ArrayDeque、PriorityQueue等。
Map接口：是映射表的基础接口
- Map（映射）：存储键值对（key-value）的集合，根据唯一的键来查找和访问值。常见的有HashMap、TreeMap等。
Iterator接口：迭代器，可以通过迭代器遍历集合中的数据

Collection接口的实现类（如ArrayList、HashSet、LinkedList、PriorityQueue等）都可以通过调用iterator()方法来获取一个迭代器。

Map接口的实现类（如HashMap、TreeMap等），它们并不直接实现Collection接口，而是提供了entrySet()和keySet()等方法来返回一个可以迭代的集合。这些方法返回的集合对象实现了Collection接口，因此可以通过这些集合对象来获取迭代器。

Iterator接口是Java集合框架提供的一种用于遍历集合元素的通用方式。它定义了一系列用于访问集合元素的方法，包括判断是否还有下一个元素、获取下一个元素、删除当前元素等操作

2.HashMap底层原理

JDK1.8之前
- `HashMap` 底层是 数组和链表 结合在一起使用也就是 链表散列。HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 (n - 1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。
- 所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法换句话说使用扰动函数之后可以减少碰撞。
JDK1.8及以后
- 相比于之前的版本， JDK1.8 之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间。
- TreeMap、TreeSet 以及 JDK1.8 之后的 HashMap 底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。

最简回答：HashMap在JDK1.7使用的是数组+链表的结构，在哈希冲突时通过链表进行解决；而JDK1.8引入了红黑树的概念，当链表长度超过一定阈值时，链表会转换成红黑树，以提高查询效率。

3.HashMap为什么用红黑树不用B树

HashMap 使用红黑树（Red-Black Tree）而不是 B 树的主要原因是效率和复杂度。

效率：红黑树相对于 B 树，在插入、删除和查找操作上具有更好的平均性能。红黑树的平衡性质可以保证树的高度相对较小，从而减少了搜索的路径长度，提高了操作的效率。
复杂度：B 树是一种多路搜索树，节点可以包含多个关键字和指针，适合用于磁盘存储等场景，可优化磁盘 IO 操作。然而，在内存中的数据结构中，红黑树的实现更为简单，代码的复杂度较低。同时，红黑树的性能在典型的 HashMap 使用场景中通常表现出良好的性能。

另外，HashMap 维护了一个哈希表和一个链表或红黑树的混合结构（JDK8 之后），当发生哈希冲突时，会使用链表或红黑树来处理冲突。链表适合处理冲突较少的情况，而红黑树则适合处理冲突较多的情况。红黑树相对于链表具有更高的查找效率，因此在冲突较多的情况下能够提供更好的性能。

总之，HashMap 使用红黑树而不是 B 树主要是出于对效率和复杂度的考虑。红黑树在内存中的实现更简单，对于典型的 HashMap 使用场景能够提供良好的性能，且适用于处理冲突较多的情况。

最简回答：HashMap使用红黑树而不是B树，是因为红黑树相对于B树在插入、删除和查找等操作上的平衡性能更好，且红黑树的节点比B树的节点更小，占用的内存更少，适合存储在内存中的数据结构。

4.HashMap什么时候扩容

在JDK1.7中，当HashMap中元素数量超过当前容量与负载因子（默认为0.75）的乘积时，会触发扩容操作，扩容后的容量为当前容量的两倍。例如，初始容量为16，当元素数量达到12时会触发扩容，扩容后的容量为32。
在JDK 1.8中，HashMap的扩容和红黑树转换是两个独立的操作，且顺序是先扩容，然后再进行红黑树的转换。当HashMap中的元素数量超过负载因子（默认为0.75）与数组容量的乘积时，会触发扩容操作。扩容会重新调整数组的大小，并将原来数组中的元素重新分配到新的数组位置上。扩容操作会导致原本哈希冲突较多的链表长度变长，因此当链表长度超过阈值（默认为8）时，会将链表转化为红黑树。综上所述，在JDK 1.8中，HashMap的操作顺序是先扩容，然后再进行红黑树的转换。扩容是为了减少哈希冲突，提高HashMap的性能和效率，而链表转红黑树的操作则是为了在特定情况下提供更好的查找、插入和删除元素的性能。

5.HashMap的长度为什么是 2的 N 次方

为了能让 HashMap 存数据和取数据的效率高，尽可能地减少 hash 值的碰撞，也就是说尽量把数

据能均匀的分配，每个链表或者红黑树长度尽量相等。我们首先可能会想到 % 取模的操作来实现。

下面是回答的重点哟：

取余（%）操作中如果除数是 2 的幂次，则等价于与其除数减一的与（&）操作（也就是说hash % length == hash &(length - 1) 的前提是 length 是 2 的 n 次方）。并且，采用二进制位操作 & ，相对于 % 能够提高运算效率。

这就是为什么 HashMap 的长度需要 2 的 N 次方了

最简回答：HashMap的长度选择为2的N次方是为了提高散列算法的效率和分布均匀性，通过使用2的幂次方作为长度，可以确保哈希码的高位和低位可以均匀参与到散列计算中，减少哈希冲突的发生，并提高散列算法的效率和性能。

6.HashMap和HashTable区别

线程是否安全： HashMap 是非线程安全的，Hashtable 是线程安全的,因为 Hashtable 内部的方法基本都经过synchronized 修饰。（如果你要保证线程安全的话就使用ConcurrentHashMap 吧！）；
对 Null key 和 Null value 的支持： HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个；Hashtable 不允许有 null 键和 null 值，否则会抛出 NullPointerException。
效率： 因为线程安全的问题，HashMap 要比Hashtable 效率高一点。另外，Hashtable 基本被淘汰，不要在代码中使用它；
初始容量大小和每次扩充容量大小的不同： ① 创建时如果不指定容量初始值，Hashtable 默认的初始大小为 11，之后每次扩充，容量变为原来的 2n+1。HashMap 默认的初始化大小为 16。之后每次扩充，容量变为原来的 2 倍。② 创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为 2 的幂次方大小（HashMap 中的tableSizeFor()方法保证，下面给出了源代码）。也就是说HashMap 总是使用 2 的幂作为哈希表的大小,后面会介绍到为什么是 2 的幂次方。
底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。

最简回答：HashMap是非线程安全的、允许空键和空值，并使用数组+链表/红黑树底层实现；HashTable是线程安全的、不允许空键和空值，并使用数组+链表底层实现。

7.ConcurrentHashMap和HashMap的区别

ConcurrentHashMap和HashMap是Java中常用的两种Map实现，它们之间有以下几个区别：

线程安全性：ConcurrentHashMap是线程安全的，多个线程可以同时对其进行读写操作而不需要额外的同步措施；而HashMap是非线程安全的，如果多个线程同时对其进行读写操作，可能会导致数据不一致或抛出异常。
锁粒度：ConcurrentHashMap通过分段锁（Segment）实现并发访问的高效性。相比之下，HashMap只能通过全局锁来保证线程安全性，因此在并发场景下性能较低。
迭代器弱一致性：ConcurrentHashMap的迭代器是弱一致的，即在迭代过程中可以容忍在迭代开始时已有的修改和在迭代期间的新增修改。HashMap的迭代器在迭代过程中如果发生结构性修改（例如增加或删除元素），会抛出ConcurrentModificationException异常。
初始容量和扩容机制：ConcurrentHashMap在初始化时可以指定并发级别和初始容量，可以通过合理设置参数来提高并发访问的效率。而HashMap默认的初始容量较小，加载因子较大，在元素数量达到一定阈值时会触发扩容操作，而扩容操作比较耗时。
null值和null键：ConcurrentHashMap中不允许存储null键和null值；而HashMap允许存储一个null键和多个null值。

总体来说，ConcurrentHashMap适用于高并发的场景，能够提供更好的性能和线程安全性；而HashMap适用于单线程环境或者在已知不存在并发访问的情况下。选择使用哪种Map实现要根据具体的需求和场景进行权衡。

最简回答：ConcurrentHashMap是线程安全的并发哈希表，支持高效地并发访问，而HashMap是非线程安全的哈希表，适用于单线程环境下的使用。

8.ConcurrentHashMap和HashTable区别，他们如何保证线程安全

- 底层数据结构：
  - JDK1.7 的 ConcurrentHashMap 底层采用分段的数组+链表 实现，JDK1.8 采用的数据结构跟 HashMap1.8 的结构一样，数组+链表/红黑二叉树。
  - Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的；
- 实现线程安全的方式（重要）：
  - ① 在 JDK1.7 的时候，ConcurrentHashMap（分段锁）对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。到了 JDK1.8 的时候已经摒弃了 Segment 的概念，而是直接用Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6 以后对 synchronized 锁做了很多优化）整个看起来就像是优化过且线程安全的HashMap，虽然在 JDK1.8 中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；
  - ② Hashtable(同一把锁) :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。

最简回答：ConcurrentHashMap和HashTable的区别在于并发性和线程安全性，ConcurrentHashMap利用分段锁（Segment）实现高效的并发访问和更新，而HashTable使用全局锁（synchronized）来保证线程安全。

9.ArrayList与LinkedList区别

是否保证线程安全： ArrayList 和LinkedList 都是不同步的，也就是不保证线程安全；
底层数据结构： Arraylist 底层使用的是Object 数组；LinkedList 底层使用的是双向链表 数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别，下面有介绍到！）
插入和删除是否受元素位置的影响：
- ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。比如：执行add(E e)方法的时候，ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
- LinkedList 采用链表存储，所以，如果是在头尾插入或者删除元素不受元素位置的影响（add(E e)、addFirst(E e)、addLast(E e)、removeFirst() 、removeLast()），近似 O(1)，如果是要在指定位置 i 插入和删除元素的话（add(int index, E element)，remove(Object o)）时间复杂度近似为 O(n) ，因为需要先移动到指定位置再插入。
是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。
内存空间占用： ArrayList 的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。
时间复杂度：
- 对于ArrayList：查询单个元素的时间复杂度为O(1)，即常数时间。由于ArrayList使用了数组来存储元素，每个元素都可以通过索引直接访问，因此根据索引获取元素的操作非常高效。
- 对于LinkedList：查询单个元素的时间复杂度为O(n)，即线性时间。由于LinkedList是基于链表实现的，每个元素只能通过遍历链表来找到目标元素，因此随着链表长度的增加，查询操作需要遍历更多的元素，导致时间复杂度增加。

最简回答：ArrayList基于数组实现，适合随机访问但插入/删除效率低；LinkedList基于链表实现，适合频繁的插入/删除操作但访问元素效率较低。

10.遍历LIST有哪些方式

- 普通遍历：for(int i=0; i< arrays.size(); i++)
- 增强for遍历：for(String str : arrays)
- foreach遍历：list.forEach((str) -> xxxxx)
- 使用Iterator迭代器遍历
- java8 stream遍历