【每日学习他人面经】小红书一面面经

1. Java中int跟integer的区别

Java 中的 int 和 Integer 是两种表示整数类型的数据。它们之间有以下几个区别：

1. 数据类型：int 是 Java 的基本数据类型，而 Integer 是 int 的封装类，属于 Java 的包装类之一。

2. 可空性：int 是一个原始数据类型，是非空的，而 Integer 是一个类，可以为 null。

3. 性能：由于 int 是基本数据类型，所以在内存占用和计算速度方面比 Integer 更高效。Integer 类型需要额外的内存来保存对象的状态信息，因此在大量数字计算或需要高效处理大量整数数据时，使用 int 可能更合适。

4. 装箱和拆箱：由于 int 和 Integer 不是同一类型，它们之间需要进行装箱（boxing）和拆箱（unboxing）操作。装箱将 int 值转换为对应的 Integer 对象，而拆箱则将 Integer 对象提取出其包含的 int 值。

5. 方法和属性：由于 Integer 是一个类，它提供了许多与整数操作相关的实用方法，如比较大小、转换为字符串等。而 int 则没有这些额外的方法和属性。

总体而言，int 适用于简单的整数运算和存储需求，而 Integer 则提供了更多的功能和灵活性，也适用于需要处理 null 值、集合操作、泛型等场景。在选择使用 int 还是 Integer 时，需要根据具体的情况考虑使用的场景和需求。

2.Threadlocal原理

ThreadLocal 是 Java 中的一个线程级别的变量，它可以在每个线程中存储和获取独立的变量副本。其原理可以简单总结如下：

1. 每个 Thread 对象中都有一个 ThreadLocalMap 类型的成员变量 threadLocals，用于存储线程的局部变量。ThreadLocalMap 是一个键值对的数据结构，键为 ThreadLocal 对象，值为线程的局部变量副本。

2. ThreadLocal 类是一个泛型类，泛型参数指定了局部变量的类型。每个使用 ThreadLocal 的线程都会创建一个特定的 ThreadLocal 实例作为键，在 ThreadLocalMap 中存储和访问对应的局部变量。

3. 当通过 ThreadLocal 的 get() 方法获取局部变量时，ThreadLocal 实例作为键在当前线程的 threadLocals 中查找对应的变量副本，并返回该副本的值。如果当前线程没有对应的变量副本，则通过 initialValue() 方法创建一个初始值，并将其存储在 threadLocals 中。

4. 当通过 ThreadLocal 的 set() 方法设置局部变量时，ThreadLocal 实例作为键在当前线程的 threadLocals 中进行存储。如果当前线程已经存在对应的键值对，则将新的值替换旧的值。

5. 当线程结束或者不再需要使用某个 ThreadLocal 时，应该手动调用 remove() 方法，将该 ThreadLocal 实例从当前线程的 threadLocals 中移除，以便垃圾回收。

通过 ThreadLocal，每个线程可以独立地使用和管理自己的局部变量，避免了线程间的数据共享和竞争条件。这种机制在多线程环境下特别有用，可以实现线程安全的操作，同时提高了程序的性能和可维护性。需要注意的是，使用 ThreadLocal 时要小心内存泄漏问题，及时清理不再需要的变量副本，避免造成内存的浪费。

3.hashMap源码有了解么，get，put方法实现

HashMap 是 Java 中常用的哈希表实现，用于存储键值对。

1. get() 方法实现：
   - 首先根据传入的 key 计算其哈希值。
   - 根据哈希值确定存储在内部数组中的桶（bucket）的索引位置。
   - 在该桶中搜索具有相同哈希值和相等 key 的节点。
   - 如果找到匹配的节点，则返回对应的 value 值；如果没有找到匹配的节点，则返回 null。

2. put() 方法实现：
   - 首先根据传入的 key 计算其哈希值和扰动函数（hash function）。
   - 根据哈希值确定存储在内部数组中的桶的索引位置。
   - 在该桶中搜索具有相同哈希值和相等 key 的节点。
   - 如果找到匹配的节点，则更新节点的 value 值。
   - 如果没有找到匹配的节点，则创建一个新的节点，并将其插入到桶中。
   - 如果插入节点后，桶中节点数量超过了负载因子（load factor）所允许的阈值，则会触发扩容操作，重新计算桶的位置。
   - 插入完成后，返回被替换的旧节点的 value 值（如果有）；如果是新插入的节点，则返回 null。

需要注意的是，HashMap 在内部使用链表或红黑树来解决哈希冲突。当桶中的节点数量较少时，使用链表表示；当节点数量超过一定阈值时，将链表转化为红黑树，以提高性能。

4.LinkedList和ArrayList区别

LinkedList 和 ArrayList 是 Java 集合框架中两种不同的 List 实现，它们在内部数据结构和操作性能上有一些区别。

1. 内部数据结构：
   - ArrayList 使用动态数组实现，内部维护一个 Object 数组来存储元素。
   - LinkedList 使用双向链表实现，每个节点都包含了前一个节点和后一个节点的引用。

2. 插入和删除操作：
   - ArrayList 在尾部进行插入和删除操作（add() 和 remove() 方法）的平均时间复杂度是 O(1)。但在中间或头部进行插入和删除操作需要移动其他元素，时间复杂度为 O(n)。
   - LinkedList 在任意位置进行插入和删除操作的平均时间复杂度是 O(1)，因为只需要调整相邻节点的指针。

3. 随机访问：
   - ArrayList 通过索引可以直接访问元素（get() 方法），时间复杂度为 O(1)。
   - LinkedList 需要从头部或尾部开始遍历链表，直到达到指定索引位置，时间复杂度为 O(n)。

4. 空间占用：
   - ArrayList 的空间占用量主要取决于实际元素数量，但可能会有额外的空间预留。
   - LinkedList 的空间占用量主要取决于实际元素数量，还会额外占用每个节点的空间。

5. 迭代操作：
   - ArrayList 的迭代操作（遍历所有元素）在插入和删除操作较少的情况下效率更高。
   - LinkedList 在需要频繁插入和删除操作的场景中，对于迭代操作可能更高效。

根据具体的使用场景和需求，可以选择更适合的集合实现。如果需要频繁地进行随机访问操作或者希望节省空间，可以选择 ArrayList。如果需要频繁地进行插入和删除操作，尤其是在中间位置，可以选择 LinkedList。

5.redis数据结构及底层实现

Redis 是一种高性能的键值存储系统，它支持多种不同的数据结构。下面是 Redis 的常见数据结构和其底层实现方式：

1. 字符串（String）：
   - 数据结构：简单的键值对，键是字符串，值可以是字符串、数字等。
   - 底层实现：使用动态字符串实现（SDS，Simple Dynamic String），在需要时自动进行内存扩容。

2. 列表（List）：
   - 数据结构：有序可重复的元素集合。
   - 底层实现：使用双向链表实现，链表节点中存储实际的元素值，同时维护一个指针指向头部和尾部。

3. 哈希（Hash）：
   - 数据结构：无序的键值对集合，其中键和值都是字符串类型。
   - 底层实现：使用哈希表实现，哈希表中的每个节点都包含一个键值对。

4. 集合（Set）：
   - 数据结构：无序且唯一的元素集合。
   - 底层实现：使用哈希表或者跳跃表实现，哈希表中的 key 存储元素值，value 始终为空；跳跃表通过有序链表来存储元素。

5. 有序集合（Sorted Set）：
   - 数据结构：有序且唯一的元素集合，每个元素都关联一个分数。
   - 底层实现：使用跳跃表和哈希表的混合实现，跳跃表中存储元素值和分数，而哈希表中存储元素值和元素在跳跃表中的索引。

除了上述主要数据结构外，Redis 还支持一些其他数据结构，如位图（Bitmap）、地理位置（Geospatial）等。

Redis 的底层实现是由 C 语言编写的。它采用了多种优化策略，例如使用内存池管理内存、异步 I/O 和事件驱动的网络模型等。此外，Redis 还提供了持久化选项，可以将数据保存到磁盘中，以防止数据丢失。

6.redis持久化机制

Redis 提供了两种持久化机制来保证数据在重启或异常情况下的持久性：RDB（Redis Database）和 AOF（Append-Only File）。

1. RDB 持久化：
   - RDB 是一种快照式持久化机制，会将数据以二进制的形式保存到磁盘文件中。
   - 触发条件：可以通过配置文件设置触发 RDB 持久化的方式，如定时保存、在指定时间内修改的键超过一定数量等。
   - 优点：
     - RDB 文件紧凑，适合用于备份和恢复数据。
     - 在恢复大量数据时，RDB 的加载速度较快。
   - 缺点：
     - RDB 机制是通过保存整个数据集合的快照来实现的，因此在意外断电等情况下可能会导致一部分数据的丢失。
     - RDB 文件的生成频率较低，如果系统出现故障，可能会导致较长时间内的数据丢失。

2. AOF 持久化：
   - AOF 是以日志的形式记录 Redis 服务器所执行的所有写操作，将这些写命令追加到一个文件中。
   - 触发条件：可以通过配置文件设置触发 AOF 持久化的方式，如每次写入操作都同步到 AOF 文件、每秒同步一次等。
   - 优点：
     - AOF 文件中保存了服务器执行的写操作序列，因此可以确保数据的完整性和持久性。
     - 恢复数据时，可以通过重新执行 AOF 文件中的写命令来重建数据集。
   - 缺点：
     - AOF 文件相对于 RDB 文件较大，占用更多的磁盘空间。
     - 在恢复大量数据时，AOF 文件的加载速度相对较慢。

可以根据实际需求选择适合的持久化机制，也可以同时启用两种持久化机制以提高数据的安全性和可靠性。

7.聊聊Springboot与SpringCloud的区别

Spring Boot 和 Spring Cloud 是两个相互关联但又具有不同职责的项目。

1. Spring Boot（简化开发）：
   - Spring Boot 是一个用于简化创建和配置 Spring 应用程序的框架。
   - 它通过提供默认配置、自动化配置和快速构建等特性，大大简化了 Spring 应用程序的开发过程。
   - Spring Boot 提供了一套强大的工具和约定，可以将常见的配置任务自动化，例如数据库连接、Web 服务器配置等。
   - 主要关注于快速搭建独立的、自包含的、可运行的 Spring 应用程序。

2. Spring Cloud（微服务架构）：
   - Spring Cloud 是一个用于构建分布式系统和微服务架构的框架。
   - 它提供了一系列的工具和组件，用于解决分布式系统的常见问题，如服务注册与发现、负载均衡、分布式配置管理、断路器模式等。
   - Spring Cloud 基于 Spring Boot，并在其基础上提供了更多的功能和集成。
   - 主要关注于构建分布式系统、微服务架构以及相关的服务治理和监控。

区别总结如下：
- 职责不同：Spring Boot 主要用于简化 Spring 应用程序的开发和配置；Spring Cloud 主要用于构建分布式系统和微服务架构。
- 功能不同：Spring Boot 提供了一套快速构建和配置 Spring 应用程序的工具和约定；Spring Cloud 提供了分布式系统中常见问题的解决方案，如服务注册与发现、负载均衡等。
- 关系紧密：Spring Cloud 是基于 Spring Boot 构建的，可以方便地集成使用。

在实际开发中，通常会结合使用 Spring Boot 和 Spring Cloud。使用 Spring Boot 可以快速创建独立的、自包含的微服务应用程序，而 Spring Cloud 则提供了一系列的工具和组件，使得这些微服务可以方便地进行服务治理和协作。

8.jvm优化了解多少

JVM（Java虚拟机）优化是指通过调整JVM的参数和配置，以改善Java应用程序的性能和资源利用率。下面是一些常见的JVM优化方面：

1. 堆内存调优：
   - 调整堆内存大小，包括初始堆大小（-Xms）和最大堆大小（-Xmx），以适应应用程序的内存需求。
   - 使用合适的垃圾回收器，如串行回收器（Serial Collector）、并行回收器（Parallel Collector）、CMS回收器（Concurrent Mark Sweep）和G1回收器（Garbage-First）等。

2. 垃圾回收器调优：
   - 根据应用程序的特点和负载情况选择合适的垃圾回收器。
   - 调整垃圾回收器的参数，如堆大小、新生代和老年代的比例、停顿时间目标等，以平衡吞吐量和延迟。

3. JIT编译器优化：
   - 利用JIT（Just-In-Time）编译器进行动态编译，将热点代码转换为本地机器码，提高执行效率。
   - 调整JIT编译器的相关参数，如编译级别、内联策略等。

4. 类加载优化：
   - 减少类加载的时间和开销，使用类缓存和预加载等技术来改善应用程序的启动性能。

5. 线程调优：
   - 合理配置线程池的大小和参数，以避免线程过多或过少导致的性能问题。
   - 使用合适的线程同步机制，如锁的粒度控制、使用CAS操作等，减少线程之间的竞争和阻塞。

6. I/O优化：
   - 使用异步I/O或非阻塞I/O方式，提高对外部资源（如数据库、文件系统）的访问效率。
   - 合理使用缓冲区和批量操作，减少I/O次数，提高数据读写的效率。

除了上述方面，还有其他一些JVM优化的细节和技巧，如使用内存分析工具识别内存泄漏、减少对象的创建和销毁、使用高效的数据结构等。值得注意的是，JVM优化需要根据具体的应用程序和环境进行调整，因此在进行优化之前需要进行性能分析和测试，以便选择合适的优化策略。

9.数据库事务的四大特性

数据库事务具有ACID四个重要特性，分别是：

1. 原子性（Atomicity）：
   - 原子性要求事务中的所有操作要么全部成功，要么全部失败。这意味着在事务执行中，如果发生错误或中断，所有已执行的操作将被回滚，数据库状态将恢复到事务开始之前的状态，不会产生部分执行的结果。

2. 一致性（Consistency）：
   - 一致性确保事务的执行不会破坏数据库的完整性约束。在事务开始和结束时，数据库必须保持一致的状态。如果事务执行失败，则数据库应该回滚到事务开始之前的一致状态。

3. 隔离性（Isolation）：
   - 隔离性要求每个事务在并发执行时都应该与其他事务相互隔离，使得每个事务感觉就像是在独立执行，不会相互干扰。事务的隔离级别可以通过设置来控制，常见的隔离级别包括读未提交（Read Uncommitted）、读已提交（Read Committed）、可重复读（Repeatable Read）和串行化（Serializable）。

4. 持久性（Durability）：
   - 持久性要求一旦事务被提交，其结果对数据库来说是永久性的，即使在系统故障或崩溃后也能够恢复。这意味着事务的提交操作要被持久化到非易失性存储介质（如硬盘）上，以防止数据丢失。

这些ACID特性确保了数据库事务的可靠性和一致性，使得多个并发的事务可以安全地同时访问数据库，从而保证了数据的完整性和准确性。根据具体的应用需求和业务场景，可以选择不同的事务隔离级别来平衡并发性能和数据一致性之间的关系。

10.B+树 结构以及对比B树？ 了解红黑树不？有啥区别

B+树是一种常用的平衡搜索树数据结构，它在文件系统和数据库索引等场景中广泛应用。相比于B树，B+树有以下特点：

1. B+树的内部节点不保存数据记录，只用于索引，而所有数据记录都保存在叶子节点上。这使得B+树的叶子节点形成了一个有序链表，便于范围查询和顺序遍历。

2. B+树的叶子节点通过指针连接成一个链表，可以方便地进行区间查找。而B树的叶子节点之间没有直接的链接，查询需要进行逐个比较。

3. B+树的非叶子节点只存储索引信息，相比之下，B树的非叶子节点既存储索引信息，也存储部分数据，占用空间较大。

4. B+树的磁盘读写性能更优。由于B+树的内部节点只存储索引，可以容纳更多的索引信息，减少磁盘I/O次数。而B树的内部节点需要存储数据，节点所能容纳的索引信息就相应减少。

红黑树是一种自平衡的二叉搜索树，通常用于实现关联数组和有序集合等数据结构。与B树和B+树相比，红黑树有以下特点：

1. 红黑树是一种二叉搜索树，而B树和B+树是多路搜索树。多路搜索树的一个主要特点是每个节点可以有多个子节点，这样可以容纳更多的关键字和数据。

2. 红黑树并不是为了优化磁盘读写而设计的，因此在磁盘或文件系统的应用中，通常使用B树或B+树来提高效率。红黑树更适合内存结构，例如在编程语言的集合类实现中广泛应用。

3. 红黑树的插入和删除操作相对复杂，需要进行颜色变换和旋转等操作来保持树的平衡。而B树和B+树的插入和删除操作相对简单，通过节点分裂和合并等方式来维持树的平衡。

总结起来，B+树适合于存储大量的有序数据以及范围查询，特别适合用于数据库索引。B树则在外存储器上具有更好的性能，对于随机访问较频繁的场景更为适用。红黑树则主要用于内存中的数据结构实现，提供较高的搜索效率和平衡性。

———————————————————————————————

今日随机力扣：简单

【有效的括号】给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true

 

class Solution {
    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>();
        char ch;
        for (int i = 0; i < s.length(); i++) {
            ch = s.charAt(i);
            //碰到左括号，就把相应的右括号入栈
            if (ch == '(') {
                deque.push(')');
            }else if (ch == '{') {
                deque.push('}');
            }else if (ch == '[') {
                deque.push(']');
            } else if (deque.isEmpty() || deque.peek() != ch) {
                return false;
            }else {//如果是右括号判断是否和栈顶元素匹配
                deque.pop();
            }
        }
        //最后判断栈中元素是否匹配
        return deque.isEmpty();
    }
}

【合并两个有序链表】将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

 

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode pre = new ListNode(-1), list3 =pre;

        while (list1 != null && list2 != null){
            if (list1.val <= list2.val){
                list3.next = new ListNode(list1.val);
                list3 = list3.next;
                list1 = list1.next;
            }else{
                list3.next = new ListNode(list2.val);
                list3 = list3.next;
                list2 = list2.next;
            }
        }

        while (list1 != null){
            list3.next =new ListNode(list1.val);
            list3 = list3.next;
            list1 = list1.next;
        }

        while (list2 != null){
            list3.next = new ListNode(list2.val);
            list3 = list3.next;
            list2 = list2.next;
        }
        return pre.next;
    }
}

今日随机力扣：中等

【括号生成】数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

 

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<String>();
        generate(res, "", 0, 0, n);
        return res;
    }
    
        //count1统计“(”的个数，count2统计“)”的个数
    public void generate(List<String> res , String ans, int count1, int count2, int n){
        
        if(count1 > n || count2 > n) return;
        
        if(count1 == n && count2 == n)  res.add(ans);
 
        
        if(count1 >= count2){
            String ans1 = new String(ans);
            generate(res, ans+"(", count1+1, count2, n);
            generate(res, ans1+")", count1, count2+1, n);
            
        }
    }
}