Arrays.sort的底层实现
Arrays.sort是Java中提供的对数组进行排序的方法，根据参数类型不同，它提供了很多重载方法：
public static void sort(Object[] a) public static void sort(byte[] a) public static void sort(float[] a) public static void sort(int[] a)
因此对于不同的数据类型，底层采用的排序算法也是不同的
如果是基本数据类型（int、double、char等）的数组，则采用的是“双轴快速排序”算法来实现的
public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0); }
双轴快速排序是对传统快速排序的改进，它通过选择两个轴值来划分数组，并在每个划分区域中进行递归排序。这种算法通常比传统的快速排序更快，特别是在大量重复元素的情况下。双轴快速排序算法是在JDK7中引入的，并在后续版本中进行了优化和改进。
而对象数组类型的话，则采用的就是归并排序和TimSort
// 1.7以前 public static void sort(Object[] a) { Object[] aux = (Object[])a.clone(); mergeSort(aux, a, 0, a.length, 0); } // 1.7以后 public static void sort(Object[] a) { if (LegacyMergeSort.userRequested) legacyMergeSort(a); else ComparableTimSort.sort(a, 0, a.length, null, 0, 0); } /** To be removed in a future release. */ private static void legacyMergeSort(Object[] a) { Object[] aux = a.clone(); mergeSort(aux, a, 0, a.length, 0); }
TimSort 是一种混合排序算法，结合了归并排序（Merge Sort）和插入排序（Insertion Sort）的特点。
BigDecimal(double)和BigDecimal(String)有什么区别
首先我们来看一下阿里巴巴Java开发手册的提示
其实我们可以看到，double本身就是不准确的表示一个值，取得是一个近似值，例如，new BigDecimal(0.1) 但是创建出来的值并不是0.1，而是0.100000000000000000055555555......等，但是new BigDecimal("0.1")时，创建出来的值正是0.1值是很准确的。当我们去看BigDecimal源码时可以发现，他的实现主要是用的是个无标度值和标度来表示的。所以在使用double时创建的是一个不准确的值，那么如何创建一个准确的小数值呢？采用的就是BigDecimal(String)，它可以完整的表示一个小数的精度
但是需要注意的是，new BigDecimal("0.10000")和new BigDecimal("0.1")这两个数的标度分别是5和1，如果使用BigDecimal的equals方法比较，得到的结果是false。
public class BigDecimal extends Number implements Comparable<BigDecimal> { private final BigInteger intVal; private final int scale; private final transient long intCompact; }
因为计算机采用二进制处理数据，但是很多小数，如0.1的二进制是一个无限循环小数，而这种数字在计算机中是无法精确表示的。所以，人们采用了一种通过近似值的方式在计算机中表示，于是就有了单精度浮点数和双精度浮点数等。所以，作为单精度浮点数的float和双精度浮点数的double，在表示小数的时候只是近似值，并不是真实值。
所以，当使用BigDecimal(Double)创建一个的时候，得到的BigDecimal是损失了精度的。而使用一个损失了精度的数字进行计算，得到的结果也是不精确的。
想要避免这个问题，可以通过BigDecimal(String)的方式创建BigDecimal，这样的情况下，0.1就会被精确的表示出来。
Char可以存储一个汉字吗
在Java中，使用的是编码时Unicode，因此char类型使用16位来表示，可以存储任何在Unicode字符集出现的字符。Unicode字符集包含了几乎所有的字符，包括常见字符、生僻字、罕见字以及其他语言的字符。所以，用char类型其实是可以存储生僻字的。
Java中的Timer定时调度任务是咋实现的
在JDK源码中是这样定义Timer类的
public class Timer { /** * The timer task queue. This data structure is shared with the timer * thread. The timer produces tasks, via its various schedule calls, * and the timer thread consumes, executing timer tasks as appropriate, * and removing them from the queue when they're obsolete. */ private final TaskQueue queue = new TaskQueue(); /** * The timer thread. */ private final TimerThread thread = new TimerThread(queue); }
可以看到，最主要的是两个变量TaskQueue和TimerThread
- TaskQueue：一个任务队列，用于存储已计划的定时任务。任务队列按照任务的执行时间进行排序，确保最早执行的任务排在队列前面。在队列中的任务可能是一次性的，也可能是周期性的。
- TimerThread：Timer 内部的后台线程，它负责扫描 TaskQueue 中的任务，检查任务的执行时间，然后在执行时间到达时执行任务的 run() 方法。TimerThread 是一个守护线程，因此当所有非守护线程完成时，它会随之终止
任务调度的核心代码如下：
class TimerThread extends Thread { boolean newTasksMayBeScheduled = true; /** * 存储 TimerTask 的队列 */ private TaskQueue queue; TimerThread(TaskQueue queue) { this.queue = queue; } public void run() { try { mainLoop(); } finally { synchronized (queue) { newTasksMayBeScheduled = false; queue.clear(); } } } /** * 主要的计时器循环。 */ private void mainLoop() { while (true) { try { TimerTask task; boolean taskFired; synchronized (queue) { // 等待队列变为非空 while (queue.isEmpty() && newTasksMayBeScheduled) queue.wait(); if (queue.isEmpty()) break; // 队列为空，将永远保持为空；线程终止 // 队列非空；查看第一个事件并执行相应操作 long currentTime, executionTime; task = queue.getMin(); synchronized (task.lock) { if (task.state == TimerTask.CANCELLED) { queue.removeMin(); continue; // 无需执行任何操作，再次轮询队列 } currentTime = System.currentTimeMillis(); executionTime = task.nextExecutionTime; if (taskFired = (executionTime <= currentTime)) { if (task.period == 0) { // 非重复，移除 queue.removeMin(); task.state = TimerTask.EXECUTED; } else { // 重复任务，重新安排 queue.rescheduleMin( task.period < 0 ? currentTime - task.period : executionTime + task.period); } } } if (!taskFired) // 任务尚未触发；等待 queue.wait(executionTime - currentTime); } if (taskFired) // 任务触发；运行它，不持有锁 task.run(); } catch (InterruptedException e) { } } } }
TimerThread的实际是在运行mainLoop方法，这个方法一进来就是一个while(true)的循环，他在循环中不断地从TaskQueue中取出第一个任务，然后判断他是否到达执行时间了，如果到了，就触发任务执行。否则就继续等一会再次执行。如此往复的重复，执行。
使用 Timer定时调度有哪些优缺点呢？
优点：实现简单啊，因为是JDK内置的定时调度任务，因此体量是比较小的，只需要在需要使用的地方调用方法即可
缺点：
1、Timer内部是单线程执行任务的，如果某个任务执行时间较长，会影响后续任务的执行。
2、如果任务抛出未捕获异常，将导致整个 Timer 线程终止，影响其他任务的执行。
3、Timer 无法提供高精度的定时任务。因为系统调度和任务执行时间的不确定性，可能导致任务执行的时间不准确。因此需要准时和高性能的定时任务采集时常采用xxl-job定时任务框架来完成。
4、虽然可以使用 cancel 方法取消任务，但这仅仅是将任务标记为取消状态，仍然会在任务队列中占用位置，无法释放资源。这可能导致内存泄漏。
5、当有大量任务时，Timer 的性能可能受到影响，因为它在每次扫描任务队列时都要进行时间比较。
6、Timer执行任务完全基于JVM内存，一旦应用重启，那么队列中的任务就都没有了
Java中的序列化机制是咋实现的
序列化是将对象转换为可传输格式的过程。 是一种数据的持久化手段。一般广泛应用于网络传输，RMI和RPC等场景中。 几乎所有的商用编程语言都有序列化的能力，不管是数据存储到硬盘，还是通过网络的微服务传输，都需要序列化能力。
在Java的序列化机制中，如果是String，枚举或者实现了Serializable接口的类，均可以通过Java的序列化机制，将类序列化为符合编码的数据流，然后通过InputStream和OutputStream将内存中的类持久化到硬盘或者网络中；同时，也可以通过反序列化机制将磁盘中的字节码再转换成内存中的类。
**如果一个类想被序列化，需要实现Serializable接口。**否则将抛出NotSerializableException异常。Serializable接口没有方法或字段，仅用于标识可序列化的语义。
自定义类通过实现Serializable接口做标识，进而在IO中实现序列化和反序列化，具体的执行路径如下：#writeObject -> #writeObject0(判断类是否是自定义类) -> #writeOrdinaryObject(区分Serializable和Externalizable) -> writeSeria
其中，在invokeWriteObject的阶段，系统就会处理自定义类的序列化方案。这是因为，在序列化操作过程中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种。
Java中的注解是干嘛的
Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。Java 注解是从 Java5 开始添加到 Java 的。
Java的注解，可以说是一种标识，标识一个类或者一个字段，常常是和反射，AOP结合起来使用。中间件一般会定义注解，如果某些类或字段符合条件，就执行某些能力。
元注解：
@Target(ElementType.METHOD) @Retention(RetentionPolicy.SOURCE) public @interface Override { }
这里面的@Target，@Retention就是元注解。
元注解有四个:@Target（表示该注解可以用于什么地方）、@Retention（表示在什么级别保存该注解信息）、@Documented（将此注解包含在javadoc中）、@Inherited（允许子类继承父类中的注解）。
一般@Target是被用的最多的。
@Retention：指定被修饰的注解的生命周期，即注解在源代码、编译时还是运行时保留。它有三个可选的枚举值：SOURCE、CLASS和RUNTIME。默认为CLASS。
import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; @Retention(RetentionPolicy.RUNTIME) public @interface MyRuntimeAnnotation { // some elements and values }
@Target：指定被修饰的注解可以应用于的元素类型，如类、方法、字段等。这样可以限制注解的使用范围，避免错误使用。
import java.lang.annotation.Target; import java.lang.annotation.ElementType; @Target({ElementType.TYPE, ElementType.METHOD}) public @interface MyTargetAnnotation { // some elements and values }
@Documented：用于指示注解是否会出现在生成的Java文档中。如果一个注解被@Documented元注解修饰，则该注解的信息会出现在API文档中，方便开发者查阅。
import java.lang.annotation.Documented; @Documented public @interface MyDocumentedAnnotation { // some elements and values }
@Inherited：指示被该注解修饰的注解是否可以被继承。默认情况下，注解不会被继承，即子类不会继承父类的注解。但如果将一个注解用@Inherited修饰，那么它就可以被子类继承。
import java.lang.annotation.Inherited; @Inherited public @interface MyInheritedAnnotation { // some elements and values }
