目录
Arrays.sort的底层实现
BigDecimal(double)和BigDecimal(String)有什么区别
Char可以存储一个汉字吗
Java中的Timer定时调度任务是咋实现的
Java中的序列化机制是咋实现的
Java中的注解是干嘛的
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) -> writeSerialData(序列化fields) -> invokeWriteObject(反射调用类自己的序列化策略)
其中，在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
}
