阿里国际二面面经，八股文问的瑟瑟发抖

2.hashcode和equals的区别

hashCode 和 equals 是 Java 中用于处理对象相等性的两个方法：

1. equals方法：
   • equals 方法是用来比较两个对象是否在逻辑上相等。根据类的设计，你可以重写 equals 方法来指定自定义的相等性判断规则。
   • 一般来说，如果你重写了 equals 方法，就应该同时重写 hashCode 方法，以保持一致性。两个对象在调用 equals 方法返回 true 时，它们的 hashCode 值应该相等。

@Override
public boolean equals(Object obj) {
    // 实现相等性判断的逻辑
}

2. hashCode方法：
   • hashCode 方法用于返回对象的哈希码，它是一个整数值。哈希码的作用是在进行集合操作时提高查找效率，例如在哈希表中存储对象。
   • 如果两个对象使用 equals 方法返回 true，它们的 hashCode 值应该相等。但是反过来并不成立，即相等的对象不一定具有相等的哈希码。
   • 如果不重写 equals 方法，Java 默认使用 Object 类的实现，它比较的是对象的引用地址，而不是逻辑相等性。

@Override
public int hashCode() {
    // 实现生成哈希码的逻辑
}

总体来说，equals 主要用于判断两个对象是否在逻辑上相等，而 hashCode 用于支持对对象的高效存储和检索。在使用自定义类作为集合的键时，确保正确实现这两个方法是很重要的。

面经专栏直通车

面经专栏下载

3.hashmap扩容，线程是否安全

HashMap 是 Java 中常用的集合类之一，用于存储键值对。

扩容机制：

1. 初始容量和负载因子：

   • HashMap 有一个初始容量和一个负载因子。初始容量是哈希表在创建时的容量，默认为 16。负载因子是一个在哈希表大小超过其容量乘以负载因子时，哈希表将进行扩容的阈值，默认为 0.75。

2. 扩容操作：

   • 当哈希表的元素个数达到了负载因子所定义的阈值，HashMap 将进行扩容操作。
   • 扩容操作包括创建一个新的哈希表，其容量为原容量的两倍，然后将所有元素重新分配到新的哈希表中。

线程安全性：

1. 非线程安全：

   • HashMap 不是线程安全的，即在多线程环境下，如果有一个线程在修改 HashMap，而另一个线程同时访问它，可能会导致不确定的结果。

2. 线程安全解决方案：

   • 如果需要在多线程环境中使用线程安全的 HashMap，可以考虑使用 ConcurrentHashMap。ConcurrentHashMap 提供了一些线程安全的操作，例如 putIfAbsent、replace 等，以及分段锁的机制，以提高并发性能。

HashMap 的扩容机制是为了保持哈希表的性能， HashMap 本身不是线程安全的。如果需要在多线程环境中使用，可以使用 ConcurrentHashMap 或者在并发访问时进行适当的同步处理。

4.怎么样的hashmap线程安全，怎么实现，currenthashmap和Hashtable的区别

在 Java 中，有几种实现线程安全的 HashMap 的方式。其中，ConcurrentHashMap 和 Hashtable 是两种常见的线程安全的 Map 实现：

1. ConcurrentHashMap:

• 分段锁机制：

  • ConcurrentHashMap 使用了分段锁机制。它将整个数据集分成多个段（segment），每个段拥有自己的锁。这样在多线程环境中，不同的线程可以同时访问不同的段，提高并发性能。

• 并发度高：

  • 因为不同的线程可以同时操作不同的段，ConcurrentHashMap 具有较高的并发度，适合在高并发的场景中使用。

• 不支持 null 键和值：

  • ConcurrentHashMap 不支持存储 null 键和值。

2. Hashtable:

• 同步整个数据结构：

  • Hashtable 使用同步方法或同步块来确保线程安全。所有的读写操作都是同步的，这意味着在多线程环境下，只能有一个线程访问 Hashtable，可能导致性能瓶颈。

• 支持 null 键和值：

  • Hashtable 支持存储 null 键和值。

• 遗留类：

  • Hashtable 是一个遗留的类，而 ConcurrentHashMap 是 Java 5 引入的，更加现代化和高效。

区别总结：

• ConcurrentHashMap 使用了分段锁机制，具有更好的并发性能，适合高并发场景。
• Hashtable 使用同步方法，整个数据结构同步，可能导致性能瓶颈。
• ConcurrentHashMap 不支持存储 null 键和值，而 Hashtable 支持。

通常推荐使用 ConcurrentHashMap，因为它相对于 Hashtable 具有更好的性能。如果需要支持 null 键或值，可以考虑使用 HashMap 并在访问时进行适当的同步处理。

5.什么是死锁，怎么发现死锁了，怎么避免死锁

死锁是指两个或多个线程在互相等待对方释放资源而无法继续执行的状态。当线程之间存在循环等待资源的情况，且每个线程都持有对方所需资源的锁时，就可能发生死锁。

如何发现死锁：

1. 线程转储（Thread Dump）：

   • 通过获取应用程序的线程转储，可以查看每个线程的状态以及持有的锁信息。死锁通常表现为一组线程互相等待。

2. 监控工具：

   • 使用监控工具，如 Java VisualVM 或类似的性能分析工具，可以观察线程的状态、锁信息等。

如何避免死锁：

1. 按序获取锁：

   • 确保所有线程按照相同的顺序获取锁。这样可以避免循环等待的情况。

2. 使用尝试获取锁：

   • 在获取锁的时候，使用尝试获取锁的方式，而不是一直等待。可以设置一个超时时间，在超时后放弃获取锁。

3. 使用锁的层次性：

   • 设计锁的层次性，确保所有线程按照一定的层次获取锁，避免发生循环等待。

4. 避免长时间持有锁：

   • 尽量减小持有锁的时间，避免在持有锁的时候执行复杂、耗时的操作。

5. 定期检查：

   • 定期检查系统中是否存在死锁，及时发现并处理。

6. 使用工具进行分析：

   • 利用死锁检测工具，如 jstack、jconsole 等，来监控和分析系统中的死锁情况。

7. 合理设计并发结构：

   • 在设计并发结构时，考虑线程安全性，避免设计上的瑕疵导致死锁的发生。

6.new怎么回收，垃圾回收机制

在 Java 中，通过 new 关键字创建的对象，其内存的管理和回收是由Java虚拟机（JVM）的垃圾回收机制来负责的。

1. 垃圾回收的原理：

• Java 使用自动内存管理，通过垃圾回收机制来释放不再被引用的对象占用的内存。
• 当对象不再被任何引用指向时，它就成为垃圾，垃圾回收机制将识别并释放这部分内存。

2. 垃圾回收的方式：

• 标记-清除算法：

  • 垃圾回收器会通过根对象开始遍历整个对象图，标记所有被引用的对象。然后清除所有未标记的对象，释放它们的内存。

• 复制算法：

  • 将内存分为两块，每次只使用其中一块。当一块内存用尽时，将存活的对象复制到另一块内存中，然后清除当前内存中的所有对象。

• 标记-整理算法：

  • 结合了标记-清除和复制算法的优点。首先标记所有存活的对象，然后将它们向一端移动，清理掉端边界以外的对象，最后释放内存。

3. 垃圾回收器的类型：

• Serial 收集器：

  • 单线程执行，适用于小型应用或者客户端应用。

• Parallel 收集器：

  • 多线程执行，适用于多核处理器，关注吞吐量。

• CMS（Concurrent Mark-Sweep）收集器：

  • 以最短停顿时间为目标，主要用于对响应时间有较高要求的应用。

• G1（Garbage First）收集器：

  • 面向服务端应用，将堆内存划分为多个区域，进行垃圾回收。

4. 手动内存管理和 new 的回收：

• Java 中，开发者无需手动释放通过 new 创建的对象。垃圾回收器会自动检测不再被引用的对象并回收它们所占用的内存。

• 开发者需要注意的是，及时释放对对象的引用可以加速垃圾回收的进行，提高程序的性能。

Java的垃圾回收机制为开发者提供了方便的内存管理手段，通过不同的垃圾回收算法和收集器，可以满足不同应用场景的需求。

7.怎么判断是否还在引用

在Java中，可以使用垃圾回收机制来判断一个对象是否还在引用。当一个对象没有任何引用指向它时，垃圾回收机制会将其标记为可回收的垃圾对象，并在适当的时候进行回收。

然而，我们也可以通过代码来判断一个对象是否还在引用。以下是几种常见的方法：

1. 引用计数法：为对象添加一个引用计数器，每当有一个引用指向该对象时，计数器加1；当引用失效时，计数器减1。当计数器为0时，表示该对象没有任何引用指向它，即可判断对象不再被引用。
2. 可达性分析算法：通过判断对象是否可达来确定是否还有引用指向它。Java中的垃圾回收器使用的就是这种算法。当一个对象不再被任何根对象（如静态变量、局部变量等）引用时，即可判断对象不再被引用。

下面是一个示例代码，演示了如何判断一个对象是否还在引用：

复制public class ObjectReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object(); // 创建一个对象
        Object ref = obj; // 引用指向该对象

        obj = null; // 将对象的引用置为null

        if (ref != null) {
            System.out.println("对象还在引用中");
        } else {
            System.out.println("对象已不再引用");
        }
    }
}

在上述示例中，当将obj的引用置为null后，通过判断ref是否为null，可以确定对象是否还在引用。如果输出结果为"对象已不再引用"，则表示对象不再被引用。

需要注意的是，Java的垃圾回收机制是自动进行的，我们无法手动控制对象的回收时机。因此，判断一个对象是否还在引用只是一种判断手段，具体的对象回收由垃圾回收机制负责。

8.什么情况下回收到老年代

在Java中，对象的内存分配和回收是由垃圾回收器（Garbage Collector）负责的。垃圾回收器会根据对象的存活时间和内存分配情况，将对象分配到不同的内存区域，包括新生代（Young Generation）和老年代（Old Generation）。

一般情况下，新创建的对象会被分配到新生代的Eden区域。当Eden区域满时，会触发一次Minor GC（新生代垃圾回收），将存活的对象复制到Survivor区域。经过多次Minor GC后，仍然存活的对象会被晋升到老年代。

除了新生代中的对象晋升到老年代外，还有以下情况会导致对象直接分配到老年代：

1. 大对象直接分配：如果需要分配的对象大小超过了老年代的阈值（通过参数-XX:PretenureSizeThreshold设置），则该对象会直接在老年代分配。
2. 长期存活的对象：如果一个对象经过多次Minor GC后仍然存活，那么它会被晋升到老年代。这是因为老年代的对象存活时间更长，可以容纳那些长期存活的对象。
3. 动态年龄判定：在Survivor区域中，对象经过多次Minor GC后仍然存活的，会根据其年龄（通过参数-XX:MaxTenuringThreshold设置）决定是否晋升到老年代。

对象被分配到老年代并不意味着它会立即被回收。老年代的垃圾回收通常是通过Major GC（Full GC）来进行的，它会对整个堆内存进行回收，包括新生代和老年代。Major GC的触发条件和具体行为会根据不同的垃圾回收器和参数设置而有所不同。

总之，对象在Java中被分配到老年代的情况包括：大对象直接分配、长期存活的对象和经过多次Minor GC后仍然存活的对象。

9.快排的原理

• 快速排序（Quicksort）是一种常用的排序算法，它的原理基于分治法（Divide and Conquer）。快速排序的基本思想是选择一个基准元素，通过一趟排序将待排序的序列分割成独立的两部分，其中一部分的所有元素都比基准元素小，另一部分的所有元素都比基准元素大，然后对这两部分继续进行排序，最终得到一个有序序列。

  具体的快速排序算法步骤如下：

  1. 选择一个基准元素（通常选择序列的第一个元素）。
  2. 设定两个指针，一个指向序列的起始位置，称为左指针（left），另一个指向序列的末尾位置，称为右指针（right）。
  3. 左指针向右移动，直到找到一个大于等于基准元素的元素。
  4. 右指针向左移动，直到找到一个小于等于基准元素的元素。
  5. 如果左指针小于等于右指针，则交换左右指针所指向的元素。
  6. 重复步骤3到步骤5，直到左指针大于右指针。
  7. 将基准元素与右指针所指向的元素进行交换，此时基准元素左边的元素都小于基准元素，右边的元素都大于基准元素。
  8. 对基准元素左边的子序列和右边的子序列分别进行递归调用快速排序算法。

  通过不断地划分子序列并对子序列进行排序，最终可以得到整个序列的有序排列。

  快速排序的时间复杂度为O(nlogn)，其中n为待排序序列的长度。它是一种原地排序算法，不需要额外的辅助空间，但是在最坏情况下（序列已经有序或逆序），时间复杂度可能达到O(n^2)。为了避免最坏情况的发生，可以采用随机选择基准元素或者三数取中法来选择基准元素，以提高算法的性能。

10.在10亿条数据里找出最大的一百条用什么方法

在10亿条数据中找出最大的一百条数据，可以使用堆排序（Heap Sort）的方法来解决。堆排序是一种基于二叉堆的排序算法，它可以在O(nlogk)的时间复杂度内找出最大的k个元素。

具体步骤如下：

1. 创建一个大小为100的最小堆（Min Heap）。
2. 遍历10亿条数据，对于每个数据项，执行以下操作：
   • 如果堆的大小小于100，将数据项插入堆中。
   • 如果堆的大小已经达到100，比较当前数据项与堆顶元素的大小：
     • 如果当前数据项大于堆顶元素，将堆顶元素替换为当前数据项，并进行堆的调整操作，以保持最小堆的性质。
     • 如果当前数据项小于等于堆顶元素，则忽略该数据项。
3. 遍历完所有数据后，最小堆中的100个元素即为最大的一百条数据。

通过使用最小堆，我们可以始终保持堆中的元素是当前最大的k个元素。每次插入新的数据项时，如果堆已满且新数据项比堆顶元素大，则替换堆顶元素，并进行堆的调整操作。这样，最终堆中的元素就是最大的k个元素。

需要注意的是，由于数据量非常大，内存可能无法一次性加载所有数据。因此，可以采用分批加载数据的方式，每次加载一部分数据进行处理，直到遍历完所有数据。

另外，为了进一步提高性能，可以使用多线程或分布式处理的方式来并行处理数据，加快查找最大的一百条数据的速度。

11.mysql的事物隔离级别和区别

MySQL支持多个事务隔离级别，用于控制并发事务的隔离程度。不同的隔离级别提供了不同的数据一致性和并发性保证。以下是MySQL中常见的四个事务隔离级别及其区别：

1. 读未提交（Read Uncommitted）：
   • 最低的隔离级别，事务中的修改可以被其他事务立即读取。
   • 存在脏读（Dirty Read）问题，即一个事务读取到了另一个事务未提交的数据。
   • 可能导致不可重复读和幻读问题。
2. 读已提交（Read Committed）：
   • 保证一个事务提交后，其他事务才能读取到其修改的数据。
   • 解决了脏读问题，但仍可能出现不可重复读和幻读问题。
3. 可重复读（Repeatable Read）：
   • 默认的隔离级别，保证在同一个事务中多次读取同一数据时，结果始终一致。
   • 通过多版本并发控制（MVCC）机制实现，读取的是事务开始时的快照数据。
   • 解决了脏读和不可重复读问题，但仍可能出现幻读问题。
4. 串行化（Serializable）：
   • 最高的隔离级别，确保事务串行执行，避免了脏读、不可重复读和幻读问题。
   • 通过对读取的数据加锁实现，保证了最高的数据一致性，但并发性较差。

需要注意的是，隔离级别越高，数据一致性越好，但并发性能也会降低。选择合适的隔离级别需要根据具体业务需求和并发访问情况进行权衡。

在MySQL中，可以通过以下方式设置事务隔离级别：

• 在连接时设置：SET SESSION TRANSACTION ISOLATION LEVEL <隔离级别>
• 在事务开始时设置：SET TRANSACTION ISOLATION LEVEL <隔离级别>
• 在创建表时设置默认隔离级别：CREATE TABLE ... ENGINE=<存储引擎> DEFAULT TRANSACTION ISOLATION LEVEL <隔离级别>

总结：MySQL的事务隔离级别包括读未提交、读已提交、可重复读和串行化。不同的隔离级别提供了不同的数据一致性和并发性保证，开发者需要根据具体需求选择合适的隔离级别。

12.索引的底层，为什么用B+树

在MySQL中，索引的底层数据结构主要有以下几种：

1. B+树（B+ Tree）：B+树是最常用的索引数据结构，它具有有序性、平衡性和磁盘访问优化等特点，适用于范围查询、排序和高效的插入、删除操作。
2. 哈希索引（Hash Index）：哈希索引使用哈希函数将键值映射到索引位置，适用于等值查询，具有快速的查找速度。但是，哈希索引不支持范围查询和排序操作，且对于键值的插入和删除操作相对较慢。
3. 全文索引（Full-Text Index）：全文索引用于对文本内容进行搜索，支持关键词的模糊匹配和全文检索。MySQL中的全文索引使用倒排索引（Inverted Index）来实现。
4. 位图索引（Bitmap Index）：位图索引使用位图来表示每个键值的存在与否，适用于低基数（Cardinality）的列，如性别、状态等。位图索引可以进行位运算来进行快速的多条件查询。
5. R树（R-Tree）：R树是一种用于空间数据的索引结构，适用于地理信息系统（GIS）等场景，可以高效地支持空间范围查询。

B+树是一种平衡的多路搜索树，它具有以下特点，使其成为数据库索引的理想选择：

1. 有序性：B+树的所有节点都按照键值的大小顺序排列，这使得B+树在范围查询和排序操作上具有良好的性能。
2. 平衡性：B+树通过自平衡的方式保持树的平衡，使得每个节点的高度相对较小，从而减少了查询的IO次数。
3. 磁盘访问优化：B+树的节点通常比内存页的大小要小，一个节点可以存储多个键值对，这样可以减少磁盘IO的次数。
4. 支持快速查找：B+树的查找操作只需要进行一次从根节点到叶子节点的遍历，而不需要回溯。
5. 支持范围查询：B+树的有序性使得范围查询变得简单，只需要在叶子节点上进行遍历即可。
6. 支持高效的插入和删除：B+树的自平衡特性使得插入和删除操作相对高效，只需要进行少量的节点分裂和合并操作。

由于数据库中的索引通常需要支持高效的查找、范围查询和排序操作，而B+树恰好具备这些特点，因此被广泛应用于数据库索引的实现中。

12.回表查询

回表查询是指在使用非聚集索引进行查询时，需要通过索引中的指针回到主键索引或者聚集索引中获取完整的数据行的过程。回表查询通常发生在以下场景中：

1. 需要查询的字段不在非聚集索引中：当查询的字段不在非聚集索引中时，数据库引擎无法直接从索引中获取完整的数据行，而是需要通过回表操作到主键索引或聚集索引中获取完整的数据行。
2. 需要返回的数据超过了非聚集索引的覆盖索引能力：覆盖索引是指索引中包含了查询所需的所有字段，可以直接从索引中获取查询结果，而无需回表操作。但是，如果需要返回的数据超过了非聚集索引的覆盖索引能力，仍然需要进行回表查询。
3. 使用了索引优化的查询：有些查询语句可能会使用到索引优化，例如使用了索引的覆盖扫描、索引合并等技术，这些优化可能会导致回表查询的发生。

回表查询会增加额外的IO操作，因为需要通过指针再次访问主键索引或聚集索引。在一些对查询性能要求较高的场景中，可以考虑使用覆盖索引或者调整查询语句的优化方式，以减少回表查询的次数。

回表查询并非一定是性能问题，有时候回表查询是必要的，特别是在需要返回完整数据行的情况下。在设计数据库表和索引时，需要根据具体的业务需求和查询场景来选择合适的索引策略，以达到最佳的查询性能。

13.redis为什么快，怎么持久化

Redis之所以快速，主要有以下几个原因：

1. 内存存储：Redis将数据存储在内存中，相比于传统的磁盘存储，内存的读写速度更快，可以达到微秒级的响应时间。
2. 单线程模型：Redis采用单线程模型，避免了多线程之间的竞争和锁的开销，简化了并发控制，提高了处理请求的效率。
3. 非阻塞IO：Redis使用了异步的非阻塞IO模型，通过IO多路复用技术（如epoll、kqueue等）实现高效的网络通信，提高了并发处理能力。
4. 简单的数据结构：Redis支持多种简单的数据结构，如字符串、哈希表、列表、集合和有序集合等，这些数据结构的实现都经过了优化，使得Redis在处理这些数据结构时更加高效。

至于Redis的持久化机制，它提供了两种持久化方式：

1. RDB（Redis Database）持久化：RDB是Redis默认的持久化方式，它通过将内存中的数据快照保存到磁盘上的二进制文件中。可以手动触发或定期自动触发RDB持久化。RDB持久化适用于数据备份和恢复，但可能会有一定的数据丢失。
2. AOF（Append-Only File）持久化：AOF持久化通过将写操作追加到文件末尾的方式来记录数据的变化，以保证数据的持久性。AOF持久化可以通过配置不同的策略来控制写入频率，包括每个写命令、每秒钟同步一次或者按照一定的时间间隔同步。AOF持久化适用于数据的持久性要求较高的场景，但相比RDB持久化，AOF持久化的文件更大，恢复速度较慢。

可以根据实际需求选择适合的持久化方式，或者同时使用RDB和AOF持久化来提高数据的安全性和可靠性。

出处飞机