JAVA面经

落叶方归根

已于 2024-10-02 22:30:45 修改

阅读量1k

点赞数 14

文章标签： java 开发语言面试

于 2024-10-01 23:15:34 首次发布

本文链接：https://blog.csdn.net/m0_61723700/article/details/142675342

版权

第一篇

java 集合有几种

ArrayList和LinkedList的区别（查询、插入、删改的代价比较）

ArrayList扩容机制，具体是怎么实现的

jvm 内存模型

实例对象储存在内存模型中哪个区域（堆）

java虚拟机

springmvc与springboot区别

springMVC controller层的请求处理过程

spring IOC 的原理和理解

五层网络模型的结构

url域名从输入到返回页面过程解析（我回答dns+http+tcp的）

聊最近项目中遇到的困难，如何克服和收获

深挖提到rocketmq消息队列，深挖有没有对比其他消息队列（没答上来）

我设计的系统具体实现了一个什么样的流程和功能

手撕 java 单例模式实现

Java集合的种类

Java集合主要分为四大类：

List：有序集合，可以重复元素。
- 例如：ArrayList, LinkedList, Vector
Set：无序集合，不允许重复元素。
- 例如：HashSet, LinkedHashSet, TreeSet
Map：键值对集合，键不允许重复。
- 例如：HashMap, LinkedHashMap, TreeMap, Hashtable
Queue：通常用于存储待处理的元素，按特定顺序排列。
- 例如：LinkedList, PriorityQueue, ArrayDeque

ArrayList与LinkedList的区别

操作	ArrayList	LinkedList
查询	O(1)	O(n)
插入	O(n) (末尾O(1))	O(1) (在首尾插入)
删除	O(n)	O(1) (在首尾删除)
内存使用	占用较少（连续内存）	占用更多（节点和指针）

ArrayList扩容机制

ArrayList初始容量为10，若添加元素超过容量，则需要进行扩容。扩容机制如下：

创建一个新的数组，大小为原数组的1.5倍。
将原数组的元素复制到新数组中。
更新引用指向新数组。

JVM内存模型

JVM内存模型主要分为以下几个区域：

堆（Heap）：用于存储对象实例。
栈（Stack）：用于存储方法调用和局部变量。
方法区（Method Area）：存储类信息、常量、静态变量等。
程序计数器（Program Counter Register）：记录当前线程执行的字节码指令地址。
本地方法栈（Native Method Stack）：用于处理本地方法的调用。

实例对象储存位置

实例对象储存在内存模型中的堆区域。

Java虚拟机

Java虚拟机（JVM）是运行Java字节码的虚拟计算机，它提供了平台无关性，并负责内存管理、加载类、执行代码等。

Spring MVC与Spring Boot的区别

Spring MVC：是一个基于Servlet的框架，提供了MVC架构支持，需要配置和搭建较多。
Spring Boot：是一个简化的Spring框架开发工具，提供开箱即用的功能，自动配置，减少样板代码和配置。

Spring MVC Controller层请求处理过程

请求由前端控制器（DispatcherServlet）接收。
DispatcherServlet根据请求URL查找对应的Controller。
调用Controller方法处理请求。
返回ModelAndView对象。
视图解析器渲染视图并返回响应。

Spring IOC的原理和理解

依赖注入（DI）：通过构造器、Setter方法或接口实现将对象之间的依赖关系交给Spring容器管理。
反转控制（IoC）：对象的创建和生命周期管理由Spring容器负责，而不是业务代码。

五层网络模型的结构

应用层（Application Layer）
传输层（Transport Layer）
网络层（Network Layer）
数据链路层（Data Link Layer）
物理层（Physical Layer）

URL域名从输入到返回页面的过程

DNS查询：将域名解析为IP地址。
TCP连接：客户端与服务器建立TCP连接。
HTTP请求：客户端发送HTTP请求到服务器。
服务器处理：服务器处理请求并生成响应。
返回响应：服务器将响应返回客户端。

最近项目中遇到的困难及克服方法

（此部分需个人经验分享）

深挖RocketMQ消息队列

RocketMQ是一款高性能的分布式消息队列，特点包括：

高可用性：支持主从复制。
高吞吐量：通过异步和批量处理提高性能。
消息顺序：支持顺序消息投递。

与其他消息队列对比，例如Kafka，RocketMQ在事务消息和顺序消息处理上表现优越，但Kafka在处理大规模数据流时更具优势。

设计的系统具体实现流程和功能

（此部分需个人项目经验分享）

手撕Java单例模式实现

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

第二篇

1、双亲委派机制

2、什么时候需要打破双亲委派

3、redo log、undo log、MVCC

4、spring 事务原理

5、Redis 高可用体现在哪些地方

6、Redis 为什么高效

7、缓存击穿、穿透

8、手撕：去除无序数组的出现次数＞1的元素
空间复杂度要求＜O(1)
时间复杂度要求＜O(N平方)
不可使用两层for循环

1. 双亲委派机制

双亲委派机制是Java类加载器的一种工作模式。其核心思想是：当一个类加载器接到类加载请求时，它首先将请求委托给它的父加载器，只有在父加载器无法完成该请求时，子加载器才会尝试自己去加载。

2. 什么时候需要打破双亲委派

打破双亲委派机制通常是在以下几种情况下：

框架拓展：例如在某些框架中需要动态加载用户自定义的类。
热加载：在开发过程中，频繁更新类，可能需要使用自定义类加载器。
插件系统：需要加载插件或模块时，可能会打破双亲委派机制，以便加载不同版本的类。

3. redo log、undo log、MVCC

Redo Log：用于记录已经提交事务的修改操作，可以保证数据库的持久性。即使系统崩溃，也能通过Redo Log恢复数据。
Undo Log：用于记录未提交事务的修改操作，以便在事务回滚时撤销对数据库的修改。
MVCC（多版本并发控制）：通过为每个事务提供一个时间戳，允许多个事务并行执行而不相互影响。每个事务看到的是数据的快照，有效避免了脏读、不可重复读和幻读。

4. Spring 事务原理

Spring事务管理通过AOP（面向切面编程）来实现，主要原理如下：

开启事务：在方法执行前，通过事务管理器创建一个新的事务。
执行业务逻辑：如果业务逻辑抛出异常，则回滚事务；否则，提交事务。
事务传播行为：通过不同的传播行为配置事务的行为，例如REQUIRED、REQUIRES_NEW等。

5. Redis 高可用体现在哪些地方

Redis高可用主要体现在以下几个方面：

主从复制：主节点将数据异步复制到从节点，提高数据安全性。
哨兵模式：监控Redis实例，自动故障转移，将从节点提升为主节点。
Cluster模式：通过分片技术实现数据的分布式存储，保证高可用性和可扩展性。

6. Redis 为什么高效

Redis高效的原因包括：

内存存储：数据存储在内存中，读写速度极快。
单线程模型：采用单线程事件循环，避免了上下文切换和锁竞争。
高效的数据结构：使用高效的数据结构（如哈希、列表、集合等）提供快速的操作。

7. 缓存击穿、穿透

缓存击穿：指某个热点数据在缓存中不存在，导致大量请求直接访问数据库，可能引发数据库压力过大。
缓存穿透：指查询一个一定不存在的数据，每次都去查询数据库，导致缓存失效。可以用布隆过滤器来避免。

8. 手撕：去除无序数组的出现次数＞1的元素

可以使用哈希表来记录元素出现的次数，然后再遍历一次去除出现次数大于1的元素。以下是实现代码：

import java.util.HashMap;
import java.util.Map;

public class RemoveDuplicates {

    public static void removeDuplicates(int[] arr) {
        Map<Integer, Integer> countMap = new HashMap<>();
        
        // 记录每个元素的出现次数
        for (int num : arr) {
            countMap.put(num, countMap.getOrDefault(num, 0) + 1);
        }

        // 遍历数组并输出出现次数<=1的元素
        for (int num : arr) {
            if (countMap.get(num) <= 1) {
                System.out.print(num + " ");
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {4, 3, 2, 7, 8, 3, 2, 1};
        removeDuplicates(arr);
    }
}

此方案的空间复杂度为O(N)，如果严格要求空间复杂度 < O(1)，可以考虑使用原地算法，但无法使用两层for循环或额外空间来存储计数。上述实现已尽量优化。

第三篇

有没有了解到固定线程池，使用场景及优劣。使用线程池会有什么限制？线程池有哪些拒绝策略？

黑马点评，秒杀逻辑实现

Redis的数据结构有哪些，RDB和AOF备份的区别，过期删除策略，内存淘汰策略

Redisson分布式锁实现原理，看门狗机制

ThreadLocal的原理，内存泄漏问题，线程池使用ThreadLocal的注意事项

HashMap是否线程安全，get的流程，底层结构，高并发下会出现哪些问题？对应的线程安全类有哪些？有什么区别？

Mysql有哪些引擎？Innodb引擎的索引结构，为什么使用B+树？建索引的注意事项（出个场景问怎么建索引），联合索引，介绍实习的Mysql优化过程

JVM堆和栈的区别，对象的生命周期，垃圾回收机制，未被回收的对象如何处理

volatile关键字的作用及原理

1. 固定线程池

使用场景：

适合处理固定数量的任务，例如定时任务、IO密集型任务等。
当系统资源有限且任务量可预估时，使用固定线程池可以有效管理线程资源。

优劣势：

优点：
- 限制线程数量，防止资源过度消耗。
- 线程复用，减少创建和销毁线程的开销。
缺点：
- 如果任务数量超过线程池大小，后续任务会被阻塞，可能导致性能下降。
- 不适合处理动态变化的任务量。

限制：

不能动态调整线程数量，必须在创建时设定。
线程的数量受限于系统资源，过多线程会导致上下文切换增加。

拒绝策略：

AbortPolicy（默认）：抛出异常。
CallerRunsPolicy：由调用线程处理该任务。
DiscardPolicy：丢弃该任务，不抛出异常。
DiscardOldestPolicy：丢弃最旧的任务，然后尝试执行当前任务。

2. 秒杀逻辑实现

秒杀逻辑实现的具体步骤

秒杀涉及高并发场景，合理的设计可以确保系统的稳定性和用户体验。以下是更详细的实现步骤：

1. 前端限流

算法选择：
- 令牌桶：设定一个固定速率，用户请求时必须获取令牌，超出速率的请求将被拒绝。
- 漏斗算法：设定一个上限，控制请求的流入速率。
实现方式：
- 前端使用JavaScript进行基本限流，后端通过API网关或中间件（如Nginx、Spring Cloud Gateway）进行限流控制。

2. 排队机制

实现请求排队：
- 使用消息队列（如RabbitMQ、Kafka）将请求放入队列，确保请求按序处理。
- 消费者从队列中逐个取出请求进行处理。
优先级控制：
- 可以为不同用户设置不同的优先级，例如VIP用户享有更高的请求处理优先权。

3. Redis库存管理

库存记录：
- 使用Redis的原子操作（如DECR）减少库存，保证操作的原子性。

javaCopy Code

Long stock = redisTemplate.opsForValue().decrement("product:stock"); if (stock < 0) { // 库存不足，逻辑处理 }

过期策略：
- 设置库存的过期时间，避免长时间未处理的请求占用Redis内存。

4. 订单处理

订单创建：
- 在减库存成功后，立即生成订单，并将订单信息写入数据库。

javaCopy Code

if (stock >= 0) { // 创建订单 orderService.createOrder(userId, productId); }

异步处理：
- 将订单创建的后续操作（如支付、发送确认邮件等）异步处理，提升用户体验。

5. 错误处理与补偿机制

失败重试：
- 对于库存不足或订单创建失败的情况，设置重试机制，将失败请求重新放入队列。
补偿机制：
- 设定超时策略，如果订单未完成，回滚库存。

6. 监控与告警

实时监控：
- 监控库存变化、请求处理情况，利用工具如Prometheus、Grafana进行可视化展示。
告警机制：
- 当请求量异常或库存不足时，及时发送告警，便于进行故障处理。

总结

通过以上几个步骤，可以有效地实现高并发情况下的秒杀逻辑，确保在高访问量下，系统能稳定运行，并为用户提供良好的体验。

3. Redis的数据结构

字符串（String）
哈希（Hash）
列表（List）
集合（Set）
有序集合（Sorted Set）

RDB与AOF的区别：

RDB：快照方式定期保存数据，恢复速度快，但数据丢失风险较大（最近几次更新）。
AOF：记录每次写操作，恢复时更准确，但启动速度较慢。

过期删除策略：

定期删除（定期扫描过期键）。
惰性删除（访问时检查并删除过期键）。

内存淘汰策略：

noeviction：不驱逐策略。
allkeys-lru：LRU策略。
volatile-lru：只针对设置了过期时间的key。
allkeys-random：随机驱逐。
volatile-random：随机驱逐设置了过期的key。

4. Redisson分布式锁实现原理

Redisson使用Redis实现分布式锁，利用Redis的SETNX命令和过期时间来控制锁的有效性。看门狗机制用于延长锁的过期时间，防止因任务执行超时而导致锁失效。

5. ThreadLocal

原理： ThreadLocal为每个线程提供一个独立的变量副本，从而避免多线程间的干扰。

内存泄漏问题：在使用ThreadLocal时，如果没有清理，会导致线程在使用完后仍持有对对象的引用，造成内存泄漏。

注意事项：

使用后应及时调用remove()方法清理ThreadLocal中的值，尤其在线程池中使用时更要小心。

6. HashMap

是否线程安全： HashMap不是线程安全的。在高并发下，多个线程同时读写可能导致数据不一致。

get的流程：

根据hash值定位到数组中的位置。
如果是链表，顺序查找匹配的key。
若为红黑树，则通过树结构查找。

高并发下的问题：

可能出现死循环（链表转树时）。
数据不一致（丢失更新）。

对应的线程安全类：

ConcurrentHashMap：分段锁，提高并发度。
Collections.synchronizedMap：包装HashMap，使用全局锁。

7. MySQL引擎

常见的MySQL引擎包括：

InnoDB：支持事务、外键、行级锁。
MyISAM：不支持事务，表级锁，读性能好。

InnoDB索引结构：采用B+树实现，支持快速查找和范围查询。

为什么使用B+树：

所有值都在叶子节点，带有链表，便于范围查询。
内部节点只存储键，提高查询效率。

建索引的注意事项：

避免对低基数的列建立索引。
频繁更新的列不适合建立索引。

联合索引：可以提高多条件查询的效率，但顺序很重要。

8. JVM堆和栈的区别

堆：用于存储对象，支持垃圾回收，大小可变。
栈：用于存储基本数据类型和对象引用，遵循先进后出（LIFO）原则，大小固定。

对象的生命周期：对象创建在堆中，经过使用后通过GC回收。

垃圾回收机制：有标记-清除、复制、标记-整理等多种算法。

未被回收的对象处理：若存在强引用则无法回收，GC会周期性地检查无用对象。

9. volatile关键字

作用：保证可见性，禁止指令重排序。

原理：使用内存屏障确保操作顺序，确保线程对变量的修改对其他线程可见。

第四篇

1. 项目遇到的困难

2. java泛型是什么

3. java优势是什么

4. java的内存回收

5. 堆和栈放什么

6. 二叉树是什么，遍历方式是什么

1. 项目遇到的困难

把项目中的难点抽离出来，把他作为困难给面试官去讲述。

或者你可以通过你遇到的bug，然后你怎么解决。

环绕这些去回答就行了。

2. Java泛型是什么

Java泛型是一种允许在类、接口和方法中定义类型参数的机制。泛型提供了类型安全的集合和算法，减少了类型转换的风险。例如：

javaCopy Code

List<String> list = new ArrayList<>();

3. Java的优势是什么

跨平台性：Java程序可以在任何支持Java虚拟机（JVM）的设备上运行。
面向对象：支持封装、继承和多态，提高代码重用性。
丰富的库：拥有大量标准库和第三方库，可以快速开发应用。
安全性：Java提供了强大的安全机制，适合网络应用。

4. Java的内存回收

Java使用垃圾回收机制（Garbage Collection, GC）自动管理内存。GC会定期检查堆中的对象，释放不再被引用的对象所占用的内存空间，从而防止内存泄漏。常见的GC算法有标记-清除、复制算法和分代收集等。

5. 堆和栈放什么

堆（Heap）：用于存储对象和实例变量，大小动态变化。所有的对象都在堆中分配内存，访问速度较慢，但生命周期长，支持垃圾回收。
栈（Stack）：用于存储基本数据类型的变量和对象的引用，大小固定。栈中的数据具有先进后出的特性，访问速度较快，但生命周期短。

6. 二叉树是什么，遍历方式是什么

二叉树：一种每个节点最多有两个子节点（左子树和右子树）的树结构。每个节点包含一个值和指向左右子节点的指针。
遍历方式：
- 前序遍历（根 -> 左 -> 右）
- 中序遍历（左 -> 根 -> 右）
- 后序遍历（左 -> 右 -> 根）
- 层序遍历（按层访问节点）

补充：

1. 标记-清除（Mark and Sweep）

过程：
1. 标记阶段：从根对象（如全局变量、栈中的引用等）开始，遍历所有可达对象，并标记它们。
2. 清除阶段：遍历堆中的所有对象，检查哪些对象没有被标记。如果未被标记，则说明该对象不可达，可以被回收。
优点：
- 实现简单，易于理解。
- 能够处理复杂的对象图。
缺点：
- 清除阶段可能导致内存碎片，因为释放的内存块不一定是连续的。
- 整个过程需要暂停应用程序（Stop-the-World），影响性能。

2. 复制算法（Copying）

过程：
- 将内存划分为两个相等的区域。在每次垃圾回收时，只使用一个区域（称为“活区”），另一个区域为空（称为“空区”）。
- 在进行GC时，从根对象开始，遍历可达对象，并将它们复制到空区。复制完成后，清空活区并交换两个区域的角色。
优点：
- 避免了内存碎片，因为所有存活对象都被复制到连续的内存块中。
- 由于只需处理一半的内存，GC效率较高，对象复制速度较快。
缺点：
- 内存利用率较低，只有一半的内存可以在任意时刻使用。
- 适合存活对象相对较少的场景。

3. 标记-整理（Mark-Compact）

过程：
1. 标记阶段：与标记-清除算法相同，首先标记所有可达对象。
2. 整理阶段：通过移动存活对象，将它们压缩到堆的一端，释放未使用的内存块，使得剩余的内存连续。
优点：
- 消除了内存碎片，因为所有存活对象都被整理到一起。
- 可以提高内存的使用效率。
缺点：
- 移动对象可能会导致更新引用的成本，尤其是在对象有多个引用时。
- 仍然需要进行“Stop-the-World”操作。

第五篇

1.负责模块的架构设计及原因？

2.有没有处理过CPU高和内存高的问题？

3.如何解决项目中锁竞争比较频繁的情况？

4.就项目中遇到比较有挑战性的问题，说说如何分析与解决？

5.与问题2相关，死锁问题的分析与具体解决办法（非八股文，具体排查思路与实践过程）？

6.MySQL MVCC的具体原理，RR下幻读问题如何解决，间隙锁死锁原因与排查思路，如何预防？

7.redolog的在磁盘上的存储方式，落盘的策略有哪些，什么情况下使用哪种策略？

8.RabbitMQ的镜像集群与普通集群有什么区别，如何保证高可用，消息的持久化机制？

9.ThreadLocal原理，以及在线程池中使用需要注意什么问题，线程池满载之后有没有什么优化策略可以避免任务丢失？

10.结合1问在项目里的MySQL主从延迟产生后，从哪些层面可以避免？

算法题：最靠近目标数的和

1. 负责模块的架构设计及原因？

在负责模块的架构设计时，通常会考虑以下几个方面：

可扩展性：选择微服务架构使得各个模块独立，可以根据需求进行独立扩展。
可维护性：清晰的模块划分和接口设计使得后续维护和更新更加便捷。
性能：通过合理的缓存策略（如Redis）和负载均衡提高系统性能。
技术选型：结合团队的技术栈和经验，选择适合的技术来实现模块功能，避免技术引入带来的学习成本。

2. 有没有处理过CPU高和内存高的问题？

是的，处理过CPU和内存高的问题，通常采取以下步骤：

监控与分析：使用工具（如Prometheus、Grafana）监控CPU和内存使用情况，确定高使用率的具体服务或线程。
性能优化：分析代码，发现可能存在的性能瓶颈，如不必要的循环、重复计算等，进行算法优化。
资源限制：在Kubernetes中设置资源请求和限制，防止某个服务占用过多资源影响其他服务。
垃圾回收调优：对于Java应用，调整JVM参数，优化GC策略，以减少内存使用和提升性能。

3. 如何解决项目中锁竞争比较频繁的情况？

为了解决锁竞争频繁的问题，可以考虑：

锁粒度优化：将大范围的锁分解为小范围的锁，以减少锁的竞争。
读写锁：采用读写锁（ReentrantReadWriteLock），允许多个读操作并发执行，减少写操作的阻塞。
异步处理：将一些高频次的操作异步化，降低对锁的依赖。
使用无锁数据结构：在特定场景下，引入无锁算法和数据结构，如ConcurrentHashMap。

4. 就项目中遇到比较有挑战性的问题，说说如何分析与解决？

面对具有挑战性的问题，通常遵循以下步骤：

问题重现：首先要能够稳定复现问题，收集足够的上下文信息。
日志分析：查阅相关日志，定位问题发生的时间点和相关操作，分析异常信息。
逐步排查：从高层到低层逐步排查，确定问题涉及的模块和关键路径。
修复与验证：提出解决方案后进行修复，再进行全面测试验证是否解决了问题。

5. 与问题2相关，死锁问题的分析与具体解决办法

处理死锁问题的步骤包括：

监控死锁：通过数据库的死锁监控工具（如MySQL的InnoDB Engine），获取死锁信息。
死锁检测：分析死锁日志，查看哪些线程和资源造成了死锁，记录涉及的SQL语句。
优化事务：尽量缩短事务的持有时间，确保在事务中仅执行必要的操作。
锁顺序一致性：确保多个线程在请求多个资源时，按照固定的顺序请求锁，避免循环等待。

6. MySQL MVCC的具体原理，RR下幻读问题解决

MVCC原理：每条记录有一个版本号，读操作会读取数据的快照，而写操作会生成新的数据版本。这样可以支持并发读写，提升性能。
幻读问题解决：在RR隔离级别下，为了避免幻读，可以使用间隙锁（Gap Locks）锁定不存在的行，防止其他事务插入新行。
死锁原因与排查思路：死锁一般由于两个事务相互等待所持有的锁。排查时，可以查看INNODB的死锁日志，识别事务间的依赖关系。
预防措施：保持事务尽量短小，避免长时间持有锁；合理选择索引，减少锁的范围。

7. Redo Log在磁盘上的存储方式，落盘策略

存储方式：Redo Log一般以顺序写入的形式存储，通常在磁盘的专用日志文件中。
落盘策略：
- fsync策略：在每次提交事务时将Redo Log写入磁盘，保证数据安全。
- 延迟写入：在一定时间内缓冲多次写入，减少磁盘IO，提高性能，但可能导致数据丢失风险。

8. RabbitMQ的镜像集群与普通集群区别

镜像集群：每个队列都有多个副本，任何一台节点故障时，仍可从其他节点提供服务，增强高可用性。
普通集群：消息只存在于一个节点，若该节点故障，消息可能会丢失。
消息持久化机制：RabbitMQ支持将消息标记为持久化（durable），在服务器重启后仍然可以恢复未消费的消息。

9. ThreadLocal原理及在线程池中使用注意事项

原理：ThreadLocal是每个线程独立持有一份变量，避免多个线程共享数据，防止数据竞争。
注意事项：在线程池中使用时，需注意清理ThreadLocal，避免内存泄漏（如在线程回收后，仍然引用旧数据）。
优化策略：如果线程池满载，可以考虑使用任务队列或增加线程池的核心线程数，确保不会因为资源不足导致任务丢失。

10. MySQL主从延迟产生后的避免方法

查询优化：确保主库的查询性能良好，避免长时间的锁等待。
binlog优化：合理配置binlog格式（如ROW），减少主从之间的同步延迟。
网络优化：优化主从之间的网络连接，确保网络带宽足够。
负载均衡：将读请求分散到从库上，减轻主库的压力，降低延迟。

算法题：最靠近目标数的和

对于“最靠近目标数的和”问题，可以采用双指针法或排序+二分查找的方法来寻找数组中两数之和最接近目标值的组合。具体实现步骤如下：

将数组排序。
设置两个指针，一个指向数组开头，另一个指向末尾。
计算当前两数之和与目标值的差距，并记录最小差距的组合。
根据当前和与目标值的比较，移动指针以寻找更接近的和。

import java.util.Arrays;

public class TwoSumClosest {
    public static int twoSumClosest(int[] nums, int target) {
        // 先对数组进行排序
        Arrays.sort(nums);
        
        int closestSum = Integer.MAX_VALUE;  // 初始化最接近的和为最大整数
        int left = 0;
        int right = nums.length - 1;  // 双指针初始化
        
        while (left < right) {
            int currentSum = nums[left] + nums[right];  // 计算当前和
            
            // 更新最接近的和
            if (Math.abs(currentSum - target) < Math.abs(closestSum - target)) {
                closestSum = currentSum;
            }
            
            // 根据当前和与目标值的比较移动指针
            if (currentSum < target) {
                left++;  // 增加和
            } else if (currentSum > target) {
                right--;  // 减少和
            } else {
                return closestSum;  // 如果刚好等于目标值，直接返回
            }
        }
        
        return closestSum;  // 返回找到的最接近的和
    }

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int target = 10;
        int result = twoSumClosest(numbers, target);
        System.out.println("The sum closest to " + target + " is " + result + ".");
    }
}

代码解释：

导入相关类：使用 Arrays 类来排序数组。
排序：对输入的数组进行排序，以便使用双指针法。
双指针初始化：设置两个指针 left 和 right，分别指向数组的开始和结束。
循环计算：
- 在 left < right 的条件下，计算当前指针指向的两数之和。
- 使用 Math.abs 来计算当前和与目标值之间的差值，并更新最接近的和。
指针移动：根据当前和与目标值的关系，决定如何移动指针。
返回结果：最终返回找到的最接近的和。

补充说明

死锁的发生条件：

死锁是指在多进程或多线程环境中，两个或多个进程相互等待对方释放资源，从而导致程序无法继续执行的状态。产生死锁的原因主要可以归结为以下四个条件：

互斥条件：至少有一个资源必须处于非共享模式，也就是说，某个资源一次只能被一个进程使用。如果其他进程请求该资源，它们就必须等待。
持有并等待条件：一个进程已经持有至少一个资源，但又在等待获取其他资源。这种情况会导致持有资源的进程无法释放其已持有的资源，从而形成循环等待。
不剥夺条件：已经分配给某个进程的资源，在该进程完成之前，不能强行剥夺。也就是说，资源只能在进程自己完成后自动释放。
循环等待条件：存在一种进程资源的循环链，其中每个进程都在等待下一个进程所持有的资源。例如，进程A等待进程B持有的资源，而进程B又在等待进程A持有的资源。

只要这四个条件同时满足，就可能发生死锁。为了避免死锁，可以采取一些策略，如资源分配图、请求顺序、时间限制等方法来进行管理和调节。

redo 和undo

在数据库管理系统中，redo 和 undo 是事务处理中的重要概念，用于保证数据的可靠性和一致性。以下是对它们的详细说明：

Undo（撤销）

定义：Undo 操作用于撤销已经执行的事务的更改。
目的：当一个事务未成功提交时（如用户选择回滚事务），Undo 操作会将数据库恢复到事务开始之前的状态。
过程：系统会记录每个事务的操作日志，以便在需要时能够逐步还原这些更改。
应用场景：在出现错误或用户请求撤销时使用。

Redo（重做）

定义：Redo 操作用于重新应用已经提交的事务的更改。
目的：在系统崩溃或故障后，确保那些已提交但未持久化到数据库的更改能够被恢复。
过程：系统会记录已提交事务的操作日志，确保在恢复过程中可以重新应用这些更改。
应用场景：在系统故障后恢复到一致状态时使用。

总结

Undo 主要用于逻辑层面，处理未完成的事务，确保撤销操作的一致性。
Redo 主要用于物理层面，确保已提交的更改在故障恢复时能够正确应用。

这两者共同确保了数据库在面对事务失败或系统崩溃时的可靠性和一致性。

什么是RR 什么是RC

在数据库管理系统中，**RR（可重复读）和RC（读取提交）**是两种不同的事务隔离级别。它们定义了事务在并发环境中如何处理读取和写入操作。以下是它们的详细说明：

1. RR（可重复读）

定义：在可重复读隔离级别下，事务在执行期间，多次读取同一数据行时，总是能得到相同的结果。即使其他事务对该数据进行了更新，当前事务仍然能看到最开始读取的数据。
特性：
- 防止不可重复读：同一事务内的多次读取总是一致的。
- 可能会遭遇幻读：如果一个事务在读取数据时，另一个事务插入了新记录，可能导致第一次读取和第二次读取之间的结果不一致。
适用场景：适用于需要保证读取一致性的场景，比如金融系统中的账户余额查询。

2. RC（读取提交）

定义：在读取提交隔离级别下，一个事务只能读取到已经提交的事务所做的更改。这意味着在读取过程中，其他事务的未提交更改不会被看到。
特性：
- 防止脏读：一个事务不能读取另一个未提交事务的更改。
- 允许不可重复读：同一事务内的多次读取可能得到不同的结果，因为其他事务可以在当前事务读取后提交新的更改。
- 也可能遭遇幻读，因为在读取过程中，可能有其他事务插入新记录。
适用场景：适合对实时性要求较高但不需要严格一致性的应用场景，如在线购物平台的产品查询。

总结

RR（可重复读）：确保同一事务内的多次读取结果一致，防止不可重复读，但可能会出现幻读。
RC（读取提交）：确保读取的是已提交的更改，防止脏读，但可能会出现不可重复读和幻读。

选择合适的隔离级别是根据具体应用需求和性能考虑的重要决策。.

第六篇：

Java中的多态是什么
方法重载和重写的区别
Java泛型是什么
泛型擦除是什么

泛型擦除时的时间

写一个多重嵌套的循环，跳出的关键字有哪些：比如循环A嵌套B，循环B嵌套C，return是跳出哪个循环，break是跳出哪个循环，continue是跳出哪个循环

在 Java 中判断相等的方式

object类中的方法有哪些

hashcode和equals在什么场景下需要都重写

两个对象相同hashcode需要相同吗？hashcode相同对象是同一个吗

string,stringbuffer,stringbuilder的区别及使用场景

string在什么时候用

java中的集合有哪些及实际用了哪些

hashset中怎么检测重复的元素的

线程和进程的区别

一个进程可以开几个虚拟机

线程的状态有哪些

synchronized和volatile

什么时候锁升级

java中的几种引用类型以及什么时候被JVM回收

ThreadLocal的源码了解过吗

Java中的静态代理和动态代理的区别

1. Java中的多态

多态是指同一方法或操作在不同对象上表现出不同的行为。主要分为两种形式：

编译时多态（方法重载）：同一方法名，根据参数列表不同而表现出不同的功能。
运行时多态（方法重写）：子类可以覆盖父类的方法，通过父类引用调用子类的方法。

2. 方法重载和重写的区别

方法重载：
- 在同一个类中，方法名相同但参数列表不同（参数类型、数量、顺序）。
- 与返回类型无关。
方法重写：
- 子类重新定义父类的方法，方法名、参数列表、返回类型都必须一致。
- 用于实现运行时多态。

3. Java泛型

Java泛型是一种允许在类、接口和方法中定义类型参数的机制，使得代码可以更灵活和安全。泛型提供了类型检查的功能，避免了类型转换的错误。

4. 泛型擦除

泛型擦除是Java编译器在编译时将泛型类型信息替换为原始类型的过程。这样做是为了保持向后兼容性，确保使用泛型的代码在运行时能够与非泛型代码一起工作。

5. 泛型擦除时的时间

泛型擦除在编译期间发生，编译器会将泛型信息转换为原始类型。因此，在运行时并不存在泛型的类型信息。

6. 多重嵌套循环的跳出关键字

在多重嵌套循环中：

return：跳出当前方法，所有循环均被跳出。
break：跳出最近的循环。
continue：跳出最近的循环的当前迭代，继续下一个迭代。

7. 在Java中判断相等的方式

在Java中，判断对象相等通常使用equals()方法，默认情况下，Object类的equals()方法比较对象的内存地址。需要根据业务需求重写equals()方法来实现按内容相等的判断。

8. Object类中的方法

Object类中的常用方法包括：

equals(Object obj)
hashCode()
toString()
clone()
finalize()
getClass()
notify()
notifyAll()
wait()

9. hashCode和equals在什么场景下需要都重写

在重写equals()方法的同时，也应重写hashCode()方法，以保证相等的对象具有相同的哈希码。最典型的场景是自定义类作为哈希表（如HashMap或HashSet）的键。

10. 两个对象相同hashCode需要相同吗？hashCode相同对象是同一个吗

相同的hashCode不代表对象相同，不同的对象可能有相同的哈希码（哈希冲突）。
如果两个对象相等，则它们的hashCode必须相同；反之不成立。

11. String, StringBuffer, StringBuilder的区别及使用场景

String：不可变字符串，线程安全，适合频繁读取的场景。
StringBuffer：可变字符串，线程安全，适合多线程环境下的字符串操作。
StringBuilder：可变字符串，不线程安全，适合单线程环境下的字符串操作，性能更优。

12. String在什么时候用

使用String时，适合于不需要修改内容的场景，如常量字符串、配置参数等。

13. Java中的集合及实际使用的集合

Java集合框架主要包括：

List：如ArrayList、LinkedList。
Set：如HashSet、TreeSet。
Map：如HashMap、TreeMap。
实际使用中，ArrayList和HashMap较为常见。

14. HashSet中怎么检测重复的元素

HashSet通过重写的equals()和hashCode()方法来检测重复元素。如果插入的元素的哈希码与已有元素相同，并且equals()返回true，则认为该元素已存在。

15. 线程和进程的区别

进程：是程序执行的基本单位，有独立的地址空间，资源管理和调度。
线程：是进程中的一个执行单元，多个线程共享进程的资源，具有更小的开销和更快的创建与销毁速度。

16. 一个进程可以开几个虚拟机

一个进程可以启动多个JVM实例，但每个JVM实例需要占用一定的系统资源，因此实际数量取决于系统性能和资源限制。

17. 线程的状态有哪些

线程的状态主要有：

新建（New）
** runnable**（就绪）
阻塞（Blocked）
等待（Waiting）
超时等待（Timed Waiting）
终止（Terminated）

18. synchronized和volatile

synchronized：用于方法或代码块，保证同一时间内只有一个线程能执行，提供了互斥锁和内存可见性。
volatile：可确保变量的值在多线程环境中的可见性，但不提供原子性。适用于状态标志等场景。

19. 什么时候锁升级

锁升级一般是指从偏向锁到轻量级锁、再到重量级锁的过程，通常发生在多个线程争用同一锁时，导致性能下降。

20. Java中的几种引用类型及什么时候被JVM回收

强引用：JVM不会回收，直到引用被解除。
软引用：当内存不足时可能被回收。
弱引用：只要进行垃圾回收就会被回收。
虚引用：只能用于监测对象是否被回收，不能单独使用。

21. ThreadLocal的源码了解过吗

ThreadLocal提供了线程局部变量，每个线程都有自己独立的变量副本，常用于避免使用全局变量导致的线程安全问题。

ThreadLocal的底层原理主要依赖于以下几个关键要素：

1. ThreadLocalMap

ThreadLocal类内部维护了一个静态成员变量ThreadLocalMap，它是一个与每个线程绑定的 Map。每个线程都有自己的 ThreadLocalMap 实例，用于存储该线程独有的 ThreadLocal 变量。

2. 存储结构

在 ThreadLocalMap 中，每个 ThreadLocal 对象作为键（key），对应的值（value）则是线程所持有的变量。
ThreadLocalMap 是一个数组，使用动态扩展来适应不同数量的 ThreadLocal 变量。

3. WeakReference

为了避免内存泄漏，当 ThreadLocal 被回收时，其在 ThreadLocalMap 中的条目会被清理。具体来说，ThreadLocalMap 中的键（即 ThreadLocal 实例）是用 WeakReference 来引用的。
这意味着如果没有强引用指向某个 ThreadLocal 实例，该实例会被垃圾回收（GC），从而避免因 ThreadLocal 引用而无法被回收的情况。

4. 访问流程

当调用 get() 方法时，ThreadLocal 会首先获取当前线程的 ThreadLocalMap，然后查找对应的键。如果找到，则返回相应的值；如果未找到，则会调用 initialValue() 方法来生成默认值，并将其存储在 ThreadLocalMap 中。

5. 清理机制

remove() 方法会移除 ThreadLocal 中的值，从而帮助释放内存。如果不调用该方法，虽然可以通过弱引用机制回收 ThreadLocal 实例，但相应的值可能仍然占用内存。

总结

ThreadLocal 的设计使得每个线程都能安全地存储独立的变量副本，且使用弱引用来减轻内存管理压力。了解这些底层原理能够帮助开发者更有效地使用 ThreadLocal，并规避潜在的内存溢出问题。

22. Java中的静态代理和动态代理的区别

静态代理：代理类在编译时确定，通常需要为每个被代理的类创建一个代理类。
动态代理：代理类在运行时生成，使用Proxy类和InvocationHandler接口，可以为多个被代理类创建代理，灵活性更高。

补充

==和equals的区别

== 和 equals 是 Java 中用于比较对象的两种不同方式，它们之间有几个关键区别：

1. 比较内容 vs. 比较引用

==：用于比较两个对象的引用是否相同，即它们是否指向同一个内存地址。对于基本数据类型，== 比较的是它们的值。
equals()：用于比较两个对象的内容是否相等。默认情况下，Object 类的 equals() 方法与 == 的行为相同，但很多类（如 String、Integer 等）重写了 equals() 方法，以提供基于内容的比较。

2. 适用场景

==：
- 用于基本数据类型的比较（如 int, char 等）。
- 在比较对象时，检查它们是否引用同一对象。
equals()：
- 当需要比较对象的逻辑内容时使用，例如判断两个字符串的内容是否相同。

3. 重写

==：不可以被重写，因为它是操作符。
equals()：可以被重写。通过重写 equals() 方法，可以定义自定义对象的相等性逻辑。

示例代码

public class Main {
    public static void main(String[] args) {
        String str1 = new String("Hello");
        String str2 = new String("Hello");

        // 使用 == 比较引用
        System.out.println(str1 == str2); // 输出: false

        // 使用 equals 比较内容
        System.out.println(str1.equals(str2)); // 输出: true
    }
}