java Instant

皇甫敏达

2023-12-01

Instant和timestamp

Instant的概念和timestamp类似。但是在表示上有一点差异。
Instant内置两个变量，一个是seconds,一个是nanos.前者是秒，后者是纳秒。
1秒 = 1000毫秒 = 1000_000_000纳秒

timestamp位于java.sql下，继承自java.util.Date.相比下有以下参数
* @param year the year minus 1900
* @param month 0 to 11
* @param date 1 to 31
* @param hour 0 to 23
* @param minute 0 to 59
* @param second 0 to 59
* @param nano 0 to 999,999,999

两者的转换也比较简单：
Instant转timestamp:

Instant start = Instant.now();
Timestamp timestamp = Timestamp.from(start);

timestamp转Instant:

timestamp.toInstant();

我们再来看下更深层的源码：
首先是toInstant

    public Instant toInstant() {
        return Instant.ofEpochSecond(super.getTime() / MILLIS_PER_SECOND, nanos);
    }

可以看到这里使用的是Instant ofEpochSecond(long epochSecond, long nanoAdjustment)这个构造函数，前者表示秒，后者则是纳秒。这里super.getTime()返回的是毫秒，所以要除毫秒/秒得到秒单位。

然后是from,同样的也是做一个秒和毫秒的转换，再调用相应的构造方法。

    public static Timestamp from(Instant instant) {
        try {
            Timestamp stamp = new Timestamp(instant.getEpochSecond() * MILLIS_PER_SECOND);
            stamp.nanos = instant.getNano();
            return stamp;
        } catch (ArithmeticException ex) {
            throw new IllegalArgumentException(ex);
        }
    }

Instant

常用Instant构造方法

Instant调用now()获取当前的时间
Instant ofEpochSecond(long epochSecond, long nanoAdjustment)传入秒和纳秒；Instant ofEpochSecond(long epochSecond)传入秒，实际上调用带值为0的纳秒构造函数
Instant ofEpochMilli(long epochMilli)传入毫秒
Instant from(TemporalAccessor temporal);
Instant parse(final CharSequence text);

在阅读parse的源码时，对lambda表达式不了解的话会感觉这个很难懂：

    public static Instant parse(final CharSequence text) {
        return DateTimeFormatter.ISO_INSTANT.parse(text, Instant::from);
    }

首先Instant::from代表的是方法引用，如果替换成lambda则为x -> Instant.from(x)
x代表的是参数，由于是单个参数所以可以省略()，那么原本就是(x)->Instant.from(x)
再来就是它可以自行推断参数类型，这里parse传入的两个参数为(CharSequence text, TemporalQuery query)：

public <T> T parse(CharSequence text, TemporalQuery<T> query)

对应的x 为TemporalQuery query
类型T是泛型，在这里这个函数最终return的会是Instant,那么T为Instant类型
即为TemporalQuery query
再看TemporalQuery源码，发现它是一个函数式接口

@FunctionalInterface
public interface TemporalQuery<R> {
    R queryFrom(TemporalAccessor temporal);
}

故最终如果不用lambda表达式转为内部类，该句为：

return DateTimeFormatter.ISO_INSTANT.parse(text, Instant::from);
----------------------------------------------------------------
return DateTimeFormatter.ISO_INSTANT.parse(text, (temporal)-> Instant.from(temporal));
----------------------------------------------------------------
return DateTimeFormatter.ISO_INSTANT.parse(text, new TemporalQuery<Instant>() {
            @Override
            public Instant queryFrom(TemporalAccessor temporal) {
                return Instant.from(temporal);
            }
        });

这里我想了很久这个temporal到底是怎么传进去的？没想明白！
但是我觉得这个可能和ActionListener listener一样.

public interface ActionListener extends EventListener {
    public void actionPerformed(ActionEvent e);

}

作为ActionListener也没有接收到一个ActionEvent类型的值，但是还是继续响应相应的事件。
即ActionEvent接收了包含事件发生的相应信息。

那么在这里TemporalAccessor应该同样的接收了TemporalQuery相关的信息。
这个只是我的猜测，如果有大佬看到麻烦解释一下谢谢~

常用方法

方法主要包含三个方面：秒，毫秒，纳秒。这里大多数方法名都比较容易理解就不赘述。

表示方法

Instant instant = Instant.now();
        instant.getEpochSecond();
        instant.getNano();
        instant.toString();
        instant.toEpochMilli();

操作方法

        instant.plusMillis(0);
        instant.plusSeconds(0);
        instant.plusNanos(0);
        instant.minusMillis(0);

省略两个常用的minus方法。

判断方法

        Instant otherInstant = Instant.now();
        instant.isAfter(otherInstant);
        instant.isBefore(otherInstant);