百度Java实习面试都这么难了吗？|0304

1、联合索引底层存储结构(和其他种类的索引的存储结构有什么区别?)

联合索引是数据库中一种常见的索引类型，它允许在多个列上创建索引，以提高查询性能。与单列索引相比，联合索引的底层存储结构有一些区别，主要体现在如何组织和存储索引数据的方式上。

1. 存储数据的组织方式：

   • 单列索引：单列索引只包含一个列的值和指向相应数据行的指针。通常，单列索引按照列值的大小顺序来组织存储数据。
   • 联合索引：联合索引则包含多个列的值，以及指向相应数据行的指针。联合索引可以按照多个列值的组合来组织存储数据，这意味着可以根据多个列的值来定位数据行。

2. 查询时的性能影响：

   • 单列索引：单列索引适合用于只涉及单个列的查询。当查询条件涉及到索引列时，数据库可以更快地定位到匹配的数据行。
   • 联合索引：联合索引适合用于涉及多个列的查询。当查询涉及到联合索引中的多个列时，数据库可以利用索引中列值的组合来快速定位匹配的数据行。

3. 索引维护的复杂性：

   • 单列索引：单列索引的维护相对简单，因为它只需要维护单个列的值和指针。
   • 联合索引：联合索引的维护相对复杂一些，因为它需要考虑多个列值的组合。当表中的数据发生变化时，数据库需要确保联合索引中的多个列值的组合保持有序，这可能需要更多的资源和时间。

联合索引在适当的情况下可以提供更好的查询性能，特别是对于涉及到联合索引中列值的组合的查询。然而，需要注意的是，联合索引的创建和维护可能会带来一些额外的开销，并且需要根据具体的查询需求和数据模式来合理选择索引策略。

面经专栏直通车

面经专栏下载

2、联合索引的叶子节点存的什么内容?

联合索引的叶子节点存储的是索引列的值以及指向对应数据行的指针（聚集索引键值）。在联合索引中，叶子节点包含了多个列的值，以及指向对应数据行的指针（者聚集索引键值）的组合。

具体来说，叶子节点中存储了索引列的实际值，以及一个指向相应数据行的指针（者聚集索引键值）。这样，当数据库引擎根据联合索引执行查询时，它可以通过索引中的列值找到对应的叶子节点，然后使用叶子节点中的指针（键值）来定位到相应的数据行。

联合索引的叶子节点存储了索引列的值和指向数据行的指针（键值）的组合，这样可以在查询时快速定位到匹配的数据行。

3、事务会不会自动提交?

MySQL 默认开启事务自动提交模式，即除非显式的开启事务（BEGIN 或 START TRANSACTION），否则每条 SOL 语句都会被当做一个单独的事务自动执行。

要启用自动提交，在执行任何DML（Data Manipulation Language）语句（例如INSERT、UPDATE、DELETE）之前，可以使用以下语句开启自动提交：

SET autocommit = 1;

或者可以在连接到数据库时在连接字符串中指定autocommit参数为1。

mysql -u username -p -h hostname dbname --autocommit=1

这将使得MySQL会话处于自动提交模式，这意味着每个单独的DML语句都将自动成为一个事务，并在执行完成后立即提交。

如果想要禁用自动提交，可以使用以下语句：

SET autocommit = 0;

或者在连接字符串中指定autocommit参数为0。

4、MySQL默认的隔离级别是什么?

MySQL的默认隔离级别是可重复读（Repeatable Read）。在可重复读隔离级别下，事务可以读取其他事务已经提交的数据，但是不会看到其他事务未提交的数据。这意味着在同一个事务中多次读取相同的数据，将会得到相同的结果，即使其他事务对该数据进行了修改也是如此。

可重复读隔离级别保证了在同一个事务中多次读取数据时的一致性，但也可能导致一些并发问题，如幻读（Phantom Read）。MySQL提供了其他隔离级别来解决不同的并发问题，包括读未提交（Read Uncommitted）、读已提交（Read Committed）和串行化（Serializable）等。

需要注意的是，虽然MySQL的默认隔离级别是可重复读，但实际上可以在会话级别或全局级别进行更改，以满足特定的应用需求。

InnoDB 当前读下的幻读是通过间隙锁（gap_lock)来实现的。在事务A查询的时候，会锁住一个间隙，其它事务往这个间隙插入、删除等操作都是会被锁阻塞的。间隙锁和插入意向锁互斥，彻底解决了当前读下的幻读问题。

但是InnoDB 没有完全解决快照读下的幻读问题。

5、Gc算法有哪些?

Java的垃圾收集（Garbage Collection，GC）算法有多种，每种算法都有其独特的特点和适用场景。以下是几种常见的Java GC算法：

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

   • 标记阶段：从根对象出发，递归地标记所有可以被访问到的对象。
   • 清除阶段：清除未被标记的对象，即不可达对象。
   • 缺点：产生内存碎片，可能导致内存分配效率降低。

2. 复制算法（Copying）：

   • 将堆内存分为两个区域：年轻代和老年代。
   • 年轻代分为Eden区和两个Survivor区。
   • 对象首先被分配到Eden区，当Eden区满时，触发Minor GC，将存活的对象复制到Survivor区，然后清空Eden区和一个Survivor区，再将存活的对象从另一个Survivor区复制到空的Survivor区。
   • 优点：不会产生内存碎片，适用于频繁回收对象的场景。

3. 标记-整理算法（Mark and Compact）：

   • 标记阶段：与标记-清除算法相同，标记所有可达对象。
   • 整理阶段：将所有存活的对象向一端移动，然后清理掉不可达对象，从而消除内存碎片。
   • 优点：不会产生内存碎片，可以提高内存分配效率。

4. 分代收集算法（Generational Collection）：

   • 将堆内存分为年轻代和老年代两部分，使用不同的GC算法。
   • 年轻代通常使用复制算法，因为大多数对象在这里很快变得不可达，适合频繁进行垃圾收集。
   • 老年代通常使用标记-清除或标记-整理算法，因为老年代存活的对象较多，适合采用更加成熟的算法来进行垃圾收集。

5. G1算法（Garbage-First）：

   • 将堆内存分成多个大小相等的区域（Region），包括年轻代、老年代和Metaspace等。
   • 将整个堆内存划分为多个Region，通过标记-复制和标记-整理的方式来执行垃圾收集。
   • G1算法通过优先收集垃圾最多的Region来提高垃圾收集效率，因此称为“Garbage-First”。

6、G1 垃圾回收器了解吗?

G1（Garbage-First）垃圾回收器是Java虚拟机（JVM）中一种现代的垃圾回收器，引入自Java 7 Update 4版本。G1垃圾回收器旨在替代CMS（Concurrent Mark-Sweep）垃圾回收器，并且在大内存堆上表现更加稳定和高效。

G1垃圾回收器具有以下特点：

1. 区域化内存管理：G1将堆内存划分为多个固定大小的区域（Region），每个区域可以是Eden区、Survivor区或Old区。这种区域化的内存管理有助于更好地控制垃圾回收过程，减少停顿时间。

2. 分代收集：虽然G1并不是一个传统的分代收集器，但它仍然将堆内存划分为年轻代和老年代，并且使用不同的垃圾回收策略来处理这两个代。

3. 并发标记清除：G1使用了并发标记（Concurrent Marking）来减少垃圾回收暂停时间。在标记阶段，G1通过并发标记线程来标记活动对象，而在应用程序运行的同时，也会继续标记操作。这样可以减少标记阶段对应用程序的影响。

4. 整理内存：G1使用了复制算法来清理内存，不再使用传统的压缩算法。在垃圾收集过程中，G1会选择一些区域进行垃圾收集，并将存活对象复制到其他区域中，从而实现内存的整理和碎片整理。

5. 垃圾优先收集：G1根据垃圾回收需求来选择优先回收的区域，以此来提高垃圾回收效率。它会优先选择包含垃圾最多的区域进行回收，从而最大程度地减少垃圾对象。

G1垃圾回收器在大内存堆上表现更加稳定和高效，尤其适用于需要低停顿时间和更加可控的垃圾回收的应用场景。

7、什么时候会触发 GC?

在Java虚拟机中，垃圾回收（GC）会在以下几种情况下触发：

1. 系统内存不足：当Java虚拟机检测到系统内存不足时，会触发垃圾回收来释放内存空间，以确保应用程序的正常运行。这通常是通过监视堆内存的使用情况来检测的。

2. 调用System.gc()方法：虽然调用System.gc()方法并不会立即触发垃圾回收，但它会向Java虚拟机发出建议性的垃圾回收请求。Java虚拟机可以选择是否立即响应这个请求。

3. 长时间停顿：当应用程序执行时间较长，而且没有进行垃圾回收时，Java虚拟机可能会为了避免堆内存耗尽而触发垃圾回收。这种情况下，垃圾回收通常会引起一段较长的停顿时间，称为Full GC。

4. Young Generation满：在分代垃圾回收器中，当Young Generation区域满时，会触发一次Minor GC。这会导致Eden区和Survivor区的垃圾回收。

5. Old Generation满：如果Old Generation区域满了，会触发一次Major GC（也称为Full GC）。这种情况下，整个堆内存都会进行垃圾回收。

6. 永久代/元空间满：对于HotSpot虚拟机，如果永久代（Java 7之前）或者元空间（Java 8及之后）满了，会触发一次垃圾回收。这种情况下，垃圾回收主要针对类的元数据和常量池。

需要注意的是，具体触发垃圾回收的时机和方式取决于Java虚拟机的实现，不同的虚拟机可能有不同的行为。此外，开发人员可以通过调整垃圾回收相关的参数来影响垃圾回收的行为，以优化应用程序的性能和资源利用率。

8、线程安全和线程不安全是什么意思?

"线程安全"和"线程不安全"是描述在多线程环境中并发操作的状态的术语。

1. 线程安全：

   • 线程安全指的是在多线程环境下，对共享数据的访问操作能够保证在并发情况下不会导致数据的不一致性或损坏。一个线程安全的操作或数据结构能够在并发访问时维持其内部状态的一致性。
   • 线程安全的实现通常会采用同步机制（例如锁、信号量等）来保护共享资源的访问，以确保在任意时刻只有一个线程能够访问共享资源，从而避免竞态条件（Race Condition）和其他并发问题。

2. 线程不安全：

   • 线程不安全指的是在多线程环境下，对共享数据的访问操作可能会导致数据的不一致性或损坏。线程不安全的操作或数据结构在并发访问时无法保证其内部状态的一致性，可能会导致意外的结果或程序错误。
   • 线程不安全的实现通常没有考虑到并发访问的情况，没有采取适当的同步措施来保护共享资源的访问，因此可能会出现竞态条件和其他并发问题。

举例来说，如果多个线程同时尝试向同一个数组中添加元素，而该数组的添加操作没有进行适当的同步控制，那么就可能导致线程不安全的情况，如数据覆盖、越界访问等。为了保证线程安全，需要在并发访问共享资源时使用适当的同步机制来确保数据的一致性。

9、场景:有一个 key 对应的 value 是一个json,结构，json,当中有好几个子任务，这些子任务如果对 key 进行修改的话,会不会存在线程安全的问题?如何解决?如果是多个节点的情况，应该怎么加锁?

在这个场景中，如果多个线程同时对同一个 key 对应的 JSON 结构中的子任务进行修改，就有可能出现线程安全的问题，因为多个线程同时对同一个数据结构进行修改可能导致数据不一致或损坏。

要解决这个问题，可以采用以下方法：

1. 使用线程安全的数据结构：可以选择使用线程安全的数据结构来存储 JSON 数据，例如 ConcurrentHashMap 或 CopyOnWriteArrayList，它们内部提供了并发访问的安全保证，能够在多线程环境下安全地进行操作。

2. 使用同步机制：可以使用同步机制（例如锁）来保护对 JSON 数据的修改操作，确保在任意时刻只有一个线程能够修改数据。比如，在对 JSON 数据进行修改之前，先获取一个锁，并在操作完成后释放锁。

3. 粒度控制：可以考虑将 JSON 数据的不同部分分别进行锁定，以减小锁的粒度，提高并发性能。比如，可以为不同的子任务或不同的节点设置不同的锁。

如果是多个节点的情况，需要在分布式环境下进行考虑。可以选择分布式锁机制来实现跨节点的数据同步和并发控制，比如使用 ZooKeeper、Redis 等分布式系统提供的分布式锁服务来确保在不同节点上对数据的并发修改操作是安全的。

10、Setnx,知道吗? 用这个加锁有什么问题吗?怎么解决?

SETNX 是 Redis 中的一个命令，用于设置键的值，但仅当键不存在时才设置成功。在分布式环境中，可以利用 SETNX 命令来实现分布式锁。具体步骤如下：

1. 客户端通过 SETNX 命令尝试将一个特定的键作为锁的标识，并设置一个唯一的值作为锁的持有者标识。
2. 如果 SETNX 命令成功执行（返回值为 1），表示当前客户端成功获取了锁，可以执行后续操作。
3. 如果 SETNX 命令执行失败（返回值为 0），表示当前锁已被其他客户端持有，当前客户端未获取到锁，需要等待一段时间后重新尝试获取锁。

虽然 SETNX 命令在某些情况下可以用来实现简单的分布式锁，但是它也存在一些问题：

1. 无法设置过期时间：SETNX 命令本身不支持设置键的过期时间，因此当持有锁的客户端发生异常或程序出现问题时，可能导致锁无法被释放，造成死锁或锁泄露问题。

2. 非原子性操作：尽管 SETNX 命令本身是原子性的，但是获取锁和释放锁通常需要多个命令的组合，例如获取锁时需要执行 SETNX，释放锁时需要执行 DEL。这种组合操作不是原子性的，可能会导致锁的不一致性问题。

为了解决这些问题，可以采用以下方法：

1. 配合 EXPIRE 命令设置过期时间：在获取锁成功后，使用 EXPIRE 命令为锁设置一个合理的过期时间，确保即使持有锁的客户端发生异常，锁也能在一定时间后自动释放。

2. 使用 Lua 脚本确保原子性：将获取锁和释放锁的操作封装在 Lua 脚本中执行，Lua 脚本可以在 Redis 中以原子性的方式执行多个命令，确保获取锁和释放锁的操作是原子性的，避免了竞态条件的发生。

3. 考虑使用 Redlock 算法等更复杂的分布式锁方案：如果应用场景要求更高的分布式锁安全性和可靠性，可以考虑使用 Redlock 算法等更复杂的分布式锁方案，这些方案通常基于多个 Redis 实例，并结合超时机制和复制机制来保证分布式锁的安全性和可靠性。

11、层次遍历一个 DAG 图，有向无环图。

以下是用 Java 实现层次遍历（BFS）一个有向无环图（DAG）的代码示例：

import java.util.*;

public class TopologicalSort {
    public List<Integer> topologicalSort(int numCourses, int[][] prerequisites) {
        List<Integer> result = new ArrayList<>();
        if (numCourses <= 0 || prerequisites == null || prerequisites.length == 0) {
            return result;
        }

        // 创建入度数组和邻接表
        int[] indegree = new int[numCourses];
        List<List<Integer>> adjacencyList = new ArrayList<>();
        for (int i = 0; i < numCourses; i++) {
            adjacencyList.add(new ArrayList<>());
        }

        // 构建入度数组和邻接表
        for (int[] prerequisite : prerequisites) {
            int course = prerequisite[0];
            int prerequisiteCourse = prerequisite[1];
            indegree[course]++;
            adjacencyList.get(prerequisiteCourse).add(course);
        }

        // 使用队列进行拓扑排序
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (indegree[i] == 0) {
                queue.offer(i);
            }
        }

        while (!queue.isEmpty()) {
            int course = queue.poll();
            result.add(course);
            for (int neighbor : adjacencyList.get(course)) {
                indegree[neighbor]--;
                if (indegree[neighbor] == 0) {
                    queue.offer(neighbor);
                }
            }
        }

        // 如果有环，则无法完成拓扑排序
        if (result.size() != numCourses) {
            return new ArrayList<>();
        }

        return result;
    }

    public static void main(String[] args) {
        int numCourses = 4;
        int[][] prerequisites = {{1, 0}, {2, 0}, {3, 1}, {3, 2}};
        TopologicalSort solution = new TopologicalSort();
        List<Integer> result = solution.topologicalSort(numCourses, prerequisites);
        System.out.println("Topological order: " + result); // Output: [0, 1, 2, 3]
    }
}

在这个示例中，定了一个 TopologicalSort 类，其中包含 topologicalSort 方法用于对有向无环图进行层次遍历（拓扑排序）。在 topologicalSort 方法中，我们首先构建了入度数组和邻接表，然后使用队列进行拓扑排序，并将排序结果保存在 result 中。最后，我们检查排序结果是否完整，如果存在环则返回空列表。

在 main 方法中，我们定义了一个示例的有向无环图，然后调用 topologicalSort 方法进行层次遍历，并输出排序结果。

12、leetcode 岛屿数量

以下是用 Java 实现 LeetCode 上「岛屿数量」问题的代码示例：

public class NumIslands {
    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }

        int numIslands = 0;
        int rows = grid.length;
        int cols = grid[0].length;

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == '1') {
                    numIslands++;
                    dfs(grid, i, j);
                }
            }
        }

        return numIslands;
    }

    private void dfs(char[][] grid, int i, int j) {
        int rows = grid.length;
        int cols = grid[0].length;

        if (i < 0 || i >= rows || j < 0 || j >= cols || grid[i][j] == '0') {
            return;
        }

        grid[i][j] = '0'; // Mark the current cell as visited

        // Explore the four neighboring cells
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
    }

    public static void main(String[] args) {
        char[][] grid = {
            {'1', '1', '0', '0', '0'},
            {'1', '1', '0', '0', '0'},
            {'0', '0', '1', '0', '0'},
            {'0', '0', '0', '1', '1'}
        };
        NumIslands solution = new NumIslands();
        int numIslands = solution.numIslands(grid);
        System.out.println("Number of islands: " + numIslands); // Output: 3
    }
}

在这个示例中，定义了一个 NumIslands 类，其中包含 numIslands 方法用于计算岛屿数量。在 numIslands 方法中，我们使用深度优先搜索（DFS）来遍历二维网格，并统计岛屿的数量。具体的深度优先搜索逻辑由 dfs 方法实现。在 main 方法中，我们定义了一个示例的二维网格 grid，并调用 numIslands 方法计算岛屿数量。

13、 有一个主任务，它有四个子任务，分别存在下面几种状态:wait,running，success，fail。用if-else 的形式写出所有可能发生的情况。

以下是使用 Java 实现主任务及其四个子任务可能的状态组合的代码示例：

public class MainTask {
    public static void main(String[] args) {
        String mainTaskStatus = "wait"; // 主任务状态
        String subTask1Status = "wait"; // 子任务1状态
        String subTask2Status = "running"; // 子任务2状态
        String subTask3Status = "success"; // 子任务3状态
        String subTask4Status = "fail"; // 子任务4状态

        if (mainTaskStatus.equals("wait")) {
            if (subTask1Status.equals("wait")) {
                System.out.println("主任务等待，子任务1等待");
            } else if (subTask1Status.equals("running")) {
                System.out.println("主任务等待，子任务1运行中");
            } else if (subTask1Status.equals("success")) {
                System.out.println("主任务等待，子任务1成功");
            } else if (subTask1Status.equals("fail")) {
                System.out.println("主任务等待，子任务1失败");
            }
        } else if (mainTaskStatus.equals("running")) {
            // 类似处理其他状态组合...
        } else if (mainTaskStatus.equals("success")) {
            // 类似处理其他状态组合...
        } else if (mainTaskStatus.equals("fail")) {
            // 类似处理其他状态组合...
        }
    }
}

这段 Java 代码中，定义了一个 MainTask 类，其中包含了 main() 方法作为程序入口。在 main() 方法中，定义了主任务和四个子任务的状态变量，并使用嵌套的 if-else 条件语句来处理不同的状态组合。根据实际需求，可以在每个条件分支中添加相应的逻辑处理。

分享者：@我真的很帅阿