Java基础知识扫盲

Arrays.sort的底层实现

BigDecimal(double)和BigDecimal(String)有什么区别

Char可以存储一个汉字吗

Java中的Timer定时调度任务是咋实现的

Java中的序列化机制是咋实现的

Java中的注解是干嘛的

Arrays.sort的底层实现

Arrays.sort是Java中提供的对数组进行排序的方法，根据参数类型不同，它提供了很多重载方法：

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等）的数组，则采用的是"双轴快速排序"算法来实现的

java 复制代码

public static void sort(int[] a) {
        DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }

双轴快速排序是对传统快速排序的改进，它通过选择两个轴值来划分数组，并在每个划分区域中进行递归排序。这种算法通常比传统的快速排序更快，特别是在大量重复元素的情况下。双轴快速排序算法是在JDK7中引入的，并在后续版本中进行了优化和改进。

而对象数组类型的话，则采用的就是归并排序和TimSort

java 复制代码

// 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。

java 复制代码

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类的

java 复制代码

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 是一个守护线程，因此当所有非守护线程完成时，它会随之终止

任务调度的核心代码如下：

java 复制代码

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结合起来使用。中间件一般会定义注解，如果某些类或字段符合条件，就执行某些能力。

元注解：

java 复制代码

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

这里面的@Target，@Retention就是元注解。

元注解有四个:@Target（表示该注解可以用于什么地方）、@Retention（表示在什么级别保存该注解信息）、@Documented（将此注解包含在javadoc中）、@Inherited（允许子类继承父类中的注解）。

一般@Target是被用的最多的。

@Retention：指定被修饰的注解的生命周期，即注解在源代码、编译时还是运行时保留。它有三个可选的枚举值：SOURCE、CLASS和RUNTIME。默认为CLASS。

java 复制代码

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface MyRuntimeAnnotation {
    // some elements and values
}

@Target：指定被修饰的注解可以应用于的元素类型，如类、方法、字段等。这样可以限制注解的使用范围，避免错误使用。

java 复制代码

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文档中，方便开发者查阅。

java 复制代码

import java.lang.annotation.Documented;

@Documented
public @interface MyDocumentedAnnotation {
    // some elements and values
}

@Inherited：指示被该注解修饰的注解是否可以被继承。默认情况下，注解不会被继承，即子类不会继承父类的注解。但如果将一个注解用@Inherited修饰，那么它就可以被子类继承。

java 复制代码

import java.lang.annotation.Inherited;

@Inherited
public @interface MyInheritedAnnotation {
    // some elements and values
}