JAVA-LocalDateTime时间格式化,转换时间戳和源码分析

LocalDateTime

LocalDateTime作为java8新加的时间类型,也是后面开发中常用的时间类型。

作为时间类型,最关注的点无非是这几个

  • 获取当前时间
  • 获取指定时间
  • 时间格式化
  • 时间转时间戳
  • 时间戳转时间
  • 时间比较
  • 时间加减

这些点通过LocalDateTime来操作,都会比较简单

获取当前时间

只需要now一下就可以获取到当前的时间,还是很方便的。

LocalDateTime time = LocalDateTime.now();

再看一下之前的Date

Date date = new Date();

获取指定时间

这个有比较多的方式

  • 通过原来的datedateTime类型来生成
  • 通过传年月日时分秒生成
LocalDateTime time = LocalDateTime.of(2022,11,30,6,6,6);

原来Date类的方式。比较奇怪,他的年份会+1900,所以2022年就得是122,月份也会+1,所以11月就是10.但是这个方法呢后面会被删除,已经被标记为弃用了,使用Calendar代替。

Date date = new Date(122,10,30,6,6,6);

看一下Calendar的使用。这个年份就正常了,是2022,但是月份还是会+1.

Calendar calendar = Calendar.getInstance();calendar.set(2022,10,30,6,6,6);

时间格式化

时间格式化都是通过format函数,需要传一个DateTimeFormatter对象进去,我们可以通过DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")来生成自己想要的格式。

DateTimeFormatter类里面也有一些定义好的格式可以直接用,除了下面列出的还有一些其他的,感兴趣可以看一下,不过我觉得都没啥用。

  • ISO_DATE_TIME 2011-12-03T10:15:30
  • ISO_OFFSET_DATE_TIME 2011-12-03T10:15:30+01:00
  • ISO_LOCAL_DATE_TIME 2011-12-03T10:15:30
time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

看一下Date的格式化。这个需要借用SimpleDateFormat类来完成格式化。

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");format.format(date);

时间转时间戳

时间转时间戳分为两种,一种是当你已经有一个LocalDateTime类型的时间了,需要转换成秒或者毫秒的时间戳。

时间转换秒级时间戳

只需要直接用toEpochSecond方法就可以了。

LocalDateTime time = LocalDateTime.now();time.toEpochSecond(ZoneOffset.ofHours(8));

Date类型没有办法直接获取秒级时间戳,只能获取毫秒级再转秒。

时间转换毫秒级时间戳

转换毫秒需要先转换成instant对象,然后才能转换成毫秒级时间戳。

LocalDateTime time = LocalDateTime.now();time.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();

Date获取毫秒就很简单了。

Date date = new Date();date.getTime();

字符串转换成时间戳

时间转时间戳分为两种,除了上面的,还有一种是有一个格式化好的字符串,比如2022-12-18 10:00:00这种,但是这个是字符串并不是时间类型。所以要先转换成LocalDateTime类型,然后就可以转换成时间戳了。

其实就是上面格式化的一种反向操作。使用parse方法就可以了。

LocalDateTime.parse("2022-12-18 10:00:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));LocalDateTime.parse("2022-12-18", DateTimeFormatter.ofPattern("yyyy-MM-dd"));

Date类型的字符串转时间戳也是通过SimpleDateFormat类来完成。

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date date = format.parse("2022-12-18 10:00:00")

时间戳转时间

那如果我们现在转换成时间戳以后又想转换成时间呢?也可以通过instant对象来做到。

毫秒时间戳转时间

Instant.ofEpochSecond(1671365543834)是将一个毫秒时间戳转换成一个instant对象。在通过ofInstant方法就可以将instant对象转换成LocalDateTime对象了。

LocalDateTime.ofInstant(Instant.ofEpochSecond(1671365543834), ZoneOffset.ofHours(8));

Date

Date date = new Date(1669759566000L);

秒时间戳转时间

Instant.ofEpochMilli(1671365543)是将一个秒时间戳转换成instant对象。和上面的区别就是使用的是ofEpochMilli方法。

LocalDateTime.ofInstant(Instant.ofEpochMilli(1671365543), ZoneOffset.ofHours(8));

Date类不支持秒,只能把秒转成毫秒在转时间戳。

时间比较

通过compareTo方法可以进行时间的一个比较大小。如果大于会返回1,小于返回-1.

LocalDateTime time = LocalDateTime.now();time.compareTo(LocalDateTime.now());

Date也是通过compareTo方法进行比较

Date date = new Date(1669759566000L);date.compareTo(new Date());

时间加减

如果加上几天,就是plusDays。加几个小时就是plusHours。当然也可以使用plus

LocalDateTime time = LocalDateTime.now();time.plusDays(1);time.plusHours(1);time.plus(Period.ofDays(1));

如果减去几天就是minusDays.减去几个小时就是minusHours。当然也可以使用minus

LocalDateTime time = LocalDateTime.now();time.minusDays(1);time.minusHours(1);time.minus(Period.ofDays(1));

Date类不支持时间加减,只能通过Calendar类实现。

Date date = new Date();Calendar calendar = Calendar.getInstance();calendar.setTime(date);calendar.add(Calendar.DAY_OF_MONTH, 1);//减去calendar.add(Calendar.DAY_OF_MONTH, -1);

时间格式在入参出参中的使用

入参的时候需要通过JsonFormat注解来指定需要的是字符串类型和对应的时间格式。

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd")private LocalDate date;@JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss")private LocalDateTime time;

出参的时候就很简单了,因为只是返回了一个字符串。

private String time;

格式化时间源码分析

格式化的时候这两个年是不一样的,具体的可以看一下源码。我们来找一下。

首先点进去是LocalDateTime这个类里面

@Override  // override for Javadoc and performancepublic String format(DateTimeFormatter formatter) {    //判断参数是否空    Objects.requireNonNull(formatter, "formatter");    //真正的执行格式化    return formatter.format(this);}

接下来点进去,看一下怎么执行的,可以看到又调用了formatTo这个函数,说明主要的格式化代码都在这里面。

public String format(TemporalAccessor temporal) {       //创建了一个32长度的字符串构建器        StringBuilder buf = new StringBuilder(32);        //格式化主要代码        formatTo(temporal, buf);        //转成字符串        return buf.toString();    }

看一下formatTo函数,可以发现主要是调用printerParser这个对象的format方法,那我们这个对象是哪来的呢,是在一开始指定格式化类型的时候来的。不同的格式化类型对应不同的解析器,也就会执行不同的format方法。

public void formatTo(TemporalAccessor temporal, Appendable appendable) {        //判断参数,这里不用管        Objects.requireNonNull(temporal, "temporal");        Objects.requireNonNull(appendable, "appendable");        try {            //创建一个DateTimePrintContext对象            DateTimePrintContext context = new DateTimePrintContext(temporal, this);            //判断,显然我们之前传过来的就是一个StringBuilder            if (appendable instanceof StringBuilder) {                //主要看这个怎么处理  这里有个 printerParser 对象,这个对象是怎么来的呢,其实是上面DateTimeFormatter.ofPattern的时候给创建的。                printerParser.format(context, (StringBuilder) appendable);            } else {                //这里其实就是如果传的不是个StringBuilder,就在创建一个然后执行                // buffer output to avoid writing to appendable in case of error                StringBuilder buf = new StringBuilder(32);                printerParser.format(context, buf);                appendable.append(buf);            }        } catch (IOException ex) {            throw new DateTimeException(ex.getMessage(), ex);        }    }

接下来我们看一下ofPattern这个方法里面是怎样的吧。这里是创建了一个 时间格式化的建造者,然后把我们这个字符串添加进去了。

//这里的字符串就是我们传的 yyyy-MM-dd HH:mm:sspublic static DateTimeFormatter ofPattern(String pattern) {    return new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter();}

看一下appendPattern里面是怎么把字符串加进去的。

public DateTimeFormatterBuilder appendPattern(String pattern) {    //忽略    Objects.requireNonNull(pattern, "pattern");    //主要的解析逻辑    parsePattern(pattern);    return this;}

继续追踪到parsePattern方法里面。这个方法代码比较多,这里只关注我们想知道的。其余的有兴趣的可以看一下。

private void parsePattern(String pattern) {    //这里给字符串做循环,注意 pattern = yyyy-MM-dd HH:mm:ss 这个字符串。    for (int pos = 0; pos < pattern.length(); pos++) {        //取出字符 比如第一个就是 y 对应的ASCII码就是121        char cur = pattern.charAt(pos);        //这里就是判断是否是大小写字母了,也就是A-Z或者a-z        if ((cur >= 'A' && cur <= 'Z') || (cur >= 'a' && cur <= 'z')) {            //初始化变量 start = 0 pos = 1            int start = pos++;            //这里做一个循环,目的其实就是找出相同的字符有几个,比如y有4个,pos就会变成4            for ( ; pos < pattern.length() && pattern.charAt(pos) == cur; pos++);  // short loop            //这里就是算出具体的数量 4 - 0 = 4            int count = pos - start;            // padding  这里忽略 我们这里面没有这个字符            if (cur == 'p') {                int pad = 0;                if (pos < pattern.length()) {                    cur = pattern.charAt(pos);                    if ((cur >= 'A' && cur <= 'Z') || (cur >= 'a' && cur <= 'z')) {                        pad = count;                        start = pos++;                        for ( ; pos < pattern.length() && pattern.charAt(pos) == cur; pos++);  // short loop                        count = pos - start;                    }                }                if (pad == 0) {                    throw new IllegalArgumentException(                            "Pad letter 'p' must be followed by valid pad pattern: " + pattern);                }                padNext(pad); // pad and continue parsing            }            //接下来是主要逻辑。            // main rules            //从hashMap里面取出对应的值,这个map放在下面了。y取出来就是 YEAR_OF_ERA            TemporalField field = FIELD_MAP.get(cur);            //判断map里面取出来的是否为空,如果不为空就直接解析,如果为空就接着往下走,看是不是 zvZOXxWwY 这几个,如果都不是就会报错了            if (field != null) {                //我们y是能取出来的,直接解析这里 cur = y, count = 4, field = YEAR_OF_ERA                parseField(cur, count, field);            } else if (cur == 'z') {                if (count > 4) {                    throw new IllegalArgumentException("Too many pattern letters: " + cur);                } else if (count == 4) {                    appendZoneText(TextStyle.FULL);                } else {                    appendZoneText(TextStyle.SHORT);                }            } else if (cur == 'V') {                if (count != 2) {                    throw new IllegalArgumentException("Pattern letter count must be 2: " + cur);                }                appendZoneId();            } else if (cur == 'Z') {                if (count < 4) {                    appendOffset("+HHMM", "+0000");                } else if (count == 4) {                    appendLocalizedOffset(TextStyle.FULL);                } else if (count == 5) {                    appendOffset("+HH:MM:ss","Z");                } else {                    throw new IllegalArgumentException("Too many pattern letters: " + cur);                }            } else if (cur == 'O') {                if (count == 1) {                    appendLocalizedOffset(TextStyle.SHORT);                } else if (count == 4) {                    appendLocalizedOffset(TextStyle.FULL);                } else {                    throw new IllegalArgumentException("Pattern letter count must be 1 or 4: " + cur);                }            } else if (cur == 'X') {                if (count > 5) {                    throw new IllegalArgumentException("Too many pattern letters: " + cur);                }                appendOffset(OffsetIdPrinterParser.PATTERNS[count + (count == 1 ? 0 : 1)], "Z");            } else if (cur == 'x') {                if (count > 5) {                    throw new IllegalArgumentException("Too many pattern letters: " + cur);                }                String zero = (count == 1 ? "+00" : (count % 2 == 0 ? "+0000" : "+00:00"));                appendOffset(OffsetIdPrinterParser.PATTERNS[count + (count == 1 ? 0 : 1)], zero);            } else if (cur == 'W') {                // Fields defined by Locale                if (count > 1) {                    throw new IllegalArgumentException("Too many pattern letters: " + cur);                }                appendInternal(new WeekBasedFieldPrinterParser(cur, count));            } else if (cur == 'w') {                // Fields defined by Locale                if (count > 2) {                    throw new IllegalArgumentException("Too many pattern letters: " + cur);                }                appendInternal(new WeekBasedFieldPrinterParser(cur, count));            } else if (cur == 'Y') {                // Fields defined by Locale                appendInternal(new WeekBasedFieldPrinterParser(cur, count));            } else {                throw new IllegalArgumentException("Unknown pattern letter: " + cur);            }            pos--;        } else if (cur == '\'') {            // parse literals            int start = pos++;            for ( ; pos < pattern.length(); pos++) {                if (pattern.charAt(pos) == '\'') {                    if (pos + 1 < pattern.length() && pattern.charAt(pos + 1) == '\'') {                        pos++;                    } else {                        break;  // end of literal                    }                }            }            if (pos >= pattern.length()) {                throw new IllegalArgumentException("Pattern ends with an incomplete string literal: " + pattern);            }            String str = pattern.substring(start + 1, pos);            if (str.length() == 0) {                appendLiteral('\'');            } else {                appendLiteral(str.replace("''", "'"));            }        } else if (cur == '[') {            optionalStart();        } else if (cur == ']') {            if (active.parent == null) {                throw new IllegalArgumentException("Pattern invalid as it contains ] without previous [");            }            optionalEnd();        } else if (cur == '{' || cur == '}' || cur == '#') {            throw new IllegalArgumentException("Pattern includes reserved character: '" + cur + "'");        } else {            // - : 这两个符号就会走到这里了            appendLiteral(cur);        }    }}

看一下通过不同的key取值的map

//时代FIELD_MAP.put('G', ChronoField.ERA);                       // SDF, LDML (different to both for 1/2 chars)//这个时代的年份,也就是我们常用的年份yyyyFIELD_MAP.put('y', ChronoField.YEAR_OF_ERA);               // SDF, LDML//单纯的年份FIELD_MAP.put('u', ChronoField.YEAR);                      // LDML (different in SDF)FIELD_MAP.put('Q', IsoFields.QUARTER_OF_YEAR);             // LDML (removed quarter from 310)FIELD_MAP.put('q', IsoFields.QUARTER_OF_YEAR);             // LDML (stand-alone)//一年里面的月份,也是我们常用的月份 MMFIELD_MAP.put('M', ChronoField.MONTH_OF_YEAR);             // SDF, LDMLFIELD_MAP.put('L', ChronoField.MONTH_OF_YEAR);             // SDF, LDML (stand-alone)//一年里面的天,我们基本不用这个作为日子FIELD_MAP.put('D', ChronoField.DAY_OF_YEAR);               // SDF, LDML//一个月里面的天,我们常用这个获取多少号FIELD_MAP.put('d', ChronoField.DAY_OF_MONTH);              // SDF, LDMLFIELD_MAP.put('F', ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH);  // SDF, LDMLFIELD_MAP.put('E', ChronoField.DAY_OF_WEEK);               // SDF, LDML (different to both for 1/2 chars)FIELD_MAP.put('c', ChronoField.DAY_OF_WEEK);               // LDML (stand-alone)FIELD_MAP.put('e', ChronoField.DAY_OF_WEEK);               // LDML (needs localized week number)FIELD_MAP.put('a', ChronoField.AMPM_OF_DAY);               // SDF, LDML//一天里面的小时,常用的小时 HHFIELD_MAP.put('H', ChronoField.HOUR_OF_DAY);               // SDF, LDMLFIELD_MAP.put('k', ChronoField.CLOCK_HOUR_OF_DAY);         // SDF, LDMLFIELD_MAP.put('K', ChronoField.HOUR_OF_AMPM);              // SDF, LDMLFIELD_MAP.put('h', ChronoField.CLOCK_HOUR_OF_AMPM);        // SDF, LDML//一个小时里面的分钟,常用的分钟 mmFIELD_MAP.put('m', ChronoField.MINUTE_OF_HOUR);            // SDF, LDML//一分钟里面的秒数,常用的秒数 ssFIELD_MAP.put('s', ChronoField.SECOND_OF_MINUTE);          // SDF, LDML//这个大S基本不用,这是秒里面的纳秒FIELD_MAP.put('S', ChronoField.NANO_OF_SECOND);            // LDML (SDF uses milli-of-second number)FIELD_MAP.put('A', ChronoField.MILLI_OF_DAY);              // LDMLFIELD_MAP.put('n', ChronoField.NANO_OF_SECOND);            // 310 (proposed for LDML)FIELD_MAP.put('N', ChronoField.NANO_OF_DAY);               // 310 (proposed for LDML)

继续深入,直接解析y的方法parseField。可以看到这个是根据我们格式化的字母执行不同的代码,比如u,y都执行到一个代码块。4个y走到了appendValue方法里面。

private void parseField(char cur, int count, TemporalField field) {    boolean standalone = false;    switch (cur) {        case 'u':        case 'y':            //判断数量            if (count == 2) {                //yy走这里                appendValueReduced(field, 2, 2, ReducedPrinterParser.BASE_DATE);            } else if (count < 4) {                //y or yyy走这里                appendValue(field, count, 19, SignStyle.NORMAL);            } else {                // yyyy走这里 field = YEAR_OF_ERA count = 4                appendValue(field, count, 19, SignStyle.EXCEEDS_PAD);            }            break;        case 'c':            if (count == 2) {                throw new IllegalArgumentException("Invalid pattern \"cc\"");            }            /*fallthrough*/        case 'L':        case 'q':            standalone = true;            /*fallthrough*/        case 'M':        case 'Q':        case 'E':        case 'e':            switch (count) {                case 1:                case 2:                    //两个MM输出月份走到这里                    if (cur == 'c' || cur == 'e') {                        appendInternal(new WeekBasedFieldPrinterParser(cur, count));                    } else if (cur == 'E') {                        appendText(field, TextStyle.SHORT);                    } else {                        if (count == 1) {                            appendValue(field);                        } else {                            //经过判断走到这里                            appendValue(field, 2);                        }                    }                    break;                case 3:                    appendText(field, standalone ? TextStyle.SHORT_STANDALONE : TextStyle.SHORT);                    break;                case 4:                    appendText(field, standalone ? TextStyle.FULL_STANDALONE : TextStyle.FULL);                    break;                case 5:                    appendText(field, standalone ? TextStyle.NARROW_STANDALONE : TextStyle.NARROW);                    break;                default:                    throw new IllegalArgumentException("Too many pattern letters: " + cur);            }            break;        case 'a':            if (count == 1) {                appendText(field, TextStyle.SHORT);            } else {                throw new IllegalArgumentException("Too many pattern letters: " + cur);            }            break;        case 'G':            switch (count) {                case 1:                case 2:                case 3:                    appendText(field, TextStyle.SHORT);                    break;                case 4:                    appendText(field, TextStyle.FULL);                    break;                case 5:                    appendText(field, TextStyle.NARROW);                    break;                default:                    throw new IllegalArgumentException("Too many pattern letters: " + cur);            }            break;        case 'S':            appendFraction(NANO_OF_SECOND, count, count, false);            break;        case 'F':            if (count == 1) {                appendValue(field);            } else {                throw new IllegalArgumentException("Too many pattern letters: " + cur);            }            break;        case 'd':        case 'h':        case 'H':        case 'k':        case 'K':        case 'm':        case 's':            if (count == 1) {                appendValue(field);            } else if (count == 2) {                //可以看到dd HH mm ss也是走到这里,最终也是通过NumberPrinterParser这个对象来格式化                appendValue(field, count);            } else {                throw new IllegalArgumentException("Too many pattern letters: " + cur);            }            break;        case 'D':            if (count == 1) {                appendValue(field);            } else if (count <= 3) {                appendValue(field, count);            } else {                throw new IllegalArgumentException("Too many pattern letters: " + cur);            }            break;        default:            if (count == 1) {                appendValue(field);            } else {                appendValue(field, count);            }            break;    }}

看一下appendValue方法。field = YEAR_OF_ERA,minWidth = 4, maxWidth = 19, signStyle = SignStyle.EXCEEDS_PAD。前面是一些判断,重点是创建了一个NumberPrinterParser的对象。最后转换的时候其实就是通过这个对象来转换的。

public DateTimeFormatterBuilder appendValue(    TemporalField field, int minWidth, int maxWidth, SignStyle signStyle) {    //这里不执行 忽略    if (minWidth == maxWidth && signStyle == SignStyle.NOT_NEGATIVE) {        return appendValue(field, maxWidth);    }    //参数校验    Objects.requireNonNull(field, "field");    Objects.requireNonNull(signStyle, "signStyle");    //一些校验规则    if (minWidth < 1 || minWidth > 19) {        throw new IllegalArgumentException("The minimum width must be from 1 to 19 inclusive but was " + minWidth);    }    if (maxWidth < 1 || maxWidth > 19) {        throw new IllegalArgumentException("The maximum width must be from 1 to 19 inclusive but was " + maxWidth);    }    if (maxWidth < minWidth) {        throw new IllegalArgumentException("The maximum width must exceed or equal the minimum width but " +                maxWidth + " < " + minWidth);    }    //重点是这里,创建了一个 NumberPrinterParser的对象,把参数传进去了。    NumberPrinterParser pp = new NumberPrinterParser(field, minWidth, maxWidth, signStyle);    appendValue(pp);    return this;}

看一下NumberPrinterParser类。还记得最开始格式化的时候那一段代码printerParser.format(context, (StringBuilder) appendable);吗,实际调用的就是这里。?

//构造方法赋值NumberPrinterParser(TemporalField field, int minWidth, int maxWidth, SignStyle signStyle) {    // validated by caller    this.field = field;    this.minWidth = minWidth;    this.maxWidth = maxWidth;    this.signStyle = signStyle;    this.subsequentWidth = 0;}//格式化方法@Overridepublic boolean format(DateTimePrintContext context, StringBuilder buf) {    //从context上下文中获取字段 field = YEAR_OF_ERA  context实际包含了真正的时间 2022-12-01T00:00:00    Long valueLong = context.getValue(field);    if (valueLong == null) {        return false;    }    //获取到以后 value = 2022    long value = getValue(context, valueLong);    DecimalStyle decimalStyle = context.getDecimalStyle();    String str = (value == Long.MIN_VALUE ? "9223372036854775808" : Long.toString(Math.abs(value)));    if (str.length() > maxWidth) {        throw new DateTimeException("Field " + field +            " cannot be printed as the value " + value +            " exceeds the maximum print width of " + maxWidth);    }    //转换一个格式类型    str = decimalStyle.convertNumberToI18N(str);    //这些条件都不满足,忽略    if (value >= 0) {        switch (signStyle) {            case EXCEEDS_PAD:                if (minWidth < 19 && value >= EXCEED_POINTS[minWidth]) {                    buf.append(decimalStyle.getPositiveSign());                }                break;            case ALWAYS:                buf.append(decimalStyle.getPositiveSign());                break;        }    } else {        switch (signStyle) {            case NORMAL:            case EXCEEDS_PAD:            case ALWAYS:                buf.append(decimalStyle.getNegativeSign());                break;            case NOT_NEGATIVE:                throw new DateTimeException("Field " + field +                    " cannot be printed as the value " + value +                    " cannot be negative according to the SignStyle");        }    }    //填充0 也就是yyyy minWidth = 4就会填充0 MM minWidth = 2如果 1月就会填充01,一个M就不会走到循环填充0    for (int i = 0; i < minWidth - str.length(); i++) {        buf.append(decimalStyle.getZeroDigit());    }    //输出到buf中    buf.append(str);    return true;}

可以看到上面的代码,但是NumberPrinterParser其实只是解析了yMdHms这些格式的。也可以再看一下M的确认一下。

首先是appendValue这个方法。大差不差,除了传到解析器的参数不一样,没啥区别,其实dd这些也都一样。

public DateTimeFormatterBuilder appendValue(TemporalField field, int width) {    //参数校验    Objects.requireNonNull(field, "field");    if (width < 1 || width > 19) {        throw new IllegalArgumentException("The width must be from 1 to 19 inclusive but was " + width);    }    //可以发现MM也是用的yyyy这个解析器格式化的,但是后面三个参数不一样    NumberPrinterParser pp = new NumberPrinterParser(field, width, width, SignStyle.NOT_NEGATIVE);    appendValue(pp);    return this;}

那我们-,:这些格式化符号的输出呢?是通过另外一个解析器,它先是取到char类型的一个字符来判断的时候会走到else里面然后走appendLiteral(cur);这个方法。看一下这个方法里面。这里可以看到主要使用的是 CharLiteralPrinterParser 这个解析器。

public DateTimeFormatterBuilder appendLiteral(char literal) {    //这里可以看到主要使用的是 CharLiteralPrinterParser 这个解析器    appendInternal(new CharLiteralPrinterParser(literal));    return this;}

看一下 CharLiteralPrinterParser 这个解析器

//构造方法CharLiteralPrinterParser(char literal) {    this.literal = literal;}@Overridepublic boolean format(DateTimePrintContext context, StringBuilder buf) {    //简单粗暴 直接把 - : 这种符号添加到字符串里面    buf.append(literal);    return true;}

接下来看一下为啥我们刚才上面说的,y代表 YEAR_OF_ERA,为啥就能从2022-12-01里面取到2022呢?这个可以看到我们NumberPrinterParser这个解析器里面主要调用了一个context.getValue(field)方法。

主要是temporal.getLong(field)方法,其实temporal就是我们的日期时间,在我们一开始创建上下文的时候过来的。回忆一下上面的创建。这里的temporal可以再往上一层传过来的,传的其实就是LocalDateTime的对象

new DateTimePrintContext(temporal, this)

Long getValue(TemporalField field) {    try {        //主要是这里,其实temporal就是我们的日期时间,在我们一开始创建上下文的时候过来的。        return temporal.getLong(field);    } catch (DateTimeException ex) {        if (optional > 0) {            return null;        }        throw ex;    }}

所以我们再看一下getLong方法。可以看到有一个类型判断,yMdHms这几个类型就会走到if里面,如果是时间的 Hms这几个调用time.getLong方法,yMd日期的调用日期的getLong方法。Y的话就会走到 getFrom 这个方法。而且是通过field调用。

@Overridepublic long getLong(TemporalField field) {    //类型判断 yMdHms这几个走的这里面    if (field instanceof ChronoField) {        ChronoField f = (ChronoField) field;        //如果是时间的 Hms这几个调用time.getLong方法,yMd日期的调用日期的getLong方法        return (f.isTimeBased() ? time.getLong(field) : date.getLong(field));    }    //Y走这个方法    return field.getFrom(this);}

看一下getFrom方法。

@Overridepublic long getFrom(TemporalAccessor temporal) {    if (rangeUnit == WEEKS) {  // day-of-week        return localizedDayOfWeek(temporal);    } else if (rangeUnit == MONTHS) {  // week-of-month        return localizedWeekOfMonth(temporal);    } else if (rangeUnit == YEARS) {  // week-of-year        return localizedWeekOfYear(temporal);    } else if (rangeUnit == WEEK_BASED_YEARS) {        return localizedWeekOfWeekBasedYear(temporal);    } else if (rangeUnit == FOREVER) {        // YYYY 大写的Y走的是这里        return localizedWeekBasedYear(temporal);    } else {        throw new IllegalStateException("unreachable, rangeUnit: " + rangeUnit + ", this: " + this);    }}

如果大写的Y格式化就会走下面的函数,主要就是取出年份以后计算周数,如果周数=0就认为是上一年的,年份-1,如果周数大于等于下一年的周数就年份+1

private int localizedWeekBasedYear(TemporalAccessor temporal) {    //获取到这周的第几天 第5天    int dow = localizedDayOfWeek(temporal);    //获取日期中的年份 2021    int year = temporal.get(YEAR);    //获取今年的第几天 2021-12-30 是 364天    int doy = temporal.get(DAY_OF_YEAR);    //这周开始的偏移量 5    int offset = startOfWeekOffset(doy, dow);    //今年的第几周 53周    int week = computeWeek(offset, doy);    //如果这周是0周,就是上一年的,年份就-1    if (week == 0) {        // Day is in end of week of previous year; return the previous year        return year - 1;    } else {        //如果接近年底,使用更高精度的逻辑        //检查 如果年份的日期包含在下一年的部分的星期里面了        // If getting close to end of year, use higher precision logic        // Check if date of year is in partial week associated with next year        //获取一年里面的天数 对象里面包含 最小1天 - 最大365天        ValueRange dayRange = temporal.range(DAY_OF_YEAR);        //获取到年份的长度,也就是365        int yearLen = (int)dayRange.getMaximum();        //下一年的周数 根据下面的计算公式得出 (7 + 5 + 366 - 1) / 7 = 53        //这里为啥是366呢,因为yearLen是今年的天数也就是365 + 1,其实也就是到下一年去了。为的是计算下一年的第一周        int newYearWeek = computeWeek(offset, yearLen + weekDef.getMinimalDaysInFirstWeek());        //比较如果今年的这周大于等于下一年的周 就年份 +1 所以这里格式化就会出错了。        if (week >= newYearWeek) {            return year + 1;        }    }    return year;}

那么是怎么计算今年的第几周的呢,看一下computeWeek方法。其实就是一个计算公式。

//offset = 5 , day = 今年的第几天 364 天private int computeWeek(int offset, int day) {    //计算公式 ( 7 + 5 + (364 - 1)) / 7    return ((7 + offset + (day - 1)) / 7);}

还有一个问题,就是我们用到了一个周的偏移量,这个偏移量怎么计算的呢,看一下这个方法startOfWeekOffset。以2021-12-30为例,day = 364,dow = 5

private int startOfWeekOffset(int day, int dow) {    // offset of first day corresponding to the day of week in first 7 days (zero origin)    //算出上一周 (364 - 5) % 7 = 2    int weekStart = Math.floorMod(day - dow, 7);    // offset = -2    int offset = -weekStart;    //这里 2 + 1  > 1会走进去    if (weekStart + 1 > weekDef.getMinimalDaysInFirstWeek()) {        // The previous week has the minimum days in the current month to be a 'week'        //这里 7 - 2 = 5 返回的就是5        offset = 7 - weekStart;    }    return offset;}

上面看完了大写的Y,再来看一下小写的y。走的getLong方法。

日期的getLong方法。经过判断后主要看get0这个方法。可以看到这个命名就很随意了。。

@Overridepublic long getLong(TemporalField field) {    //这个判断也会走进来    if (field instanceof ChronoField) {        //这两个判断忽略        if (field == EPOCH_DAY) {            return toEpochDay();        }        if (field == PROLEPTIC_MONTH) {            return getProlepticMonth();        }        //走到这里        return get0(field);    }    return field.getFrom(this);}

看一下日期的get0方法。可以发现了,这里主要处理了这几种类型。我们常用的

  • y也就是YEAR_OF_ERA 处理很简单,判断了一下year >= 1就返回 year。
  • M也就是MONTH_OF_YEAR 处理很简单,返回日期的month.
  • d也就是DAY_OF_MONTH 返回日期的day.

从这里也可以看出我们格式化成YEARERA作为年其实也是可以的。

private int get0(TemporalField field) {    switch ((ChronoField) field) {        case DAY_OF_WEEK: return getDayOfWeek().getValue();        case ALIGNED_DAY_OF_WEEK_IN_MONTH: return ((day - 1) % 7) + 1;        case ALIGNED_DAY_OF_WEEK_IN_YEAR: return ((getDayOfYear() - 1) % 7) + 1;        case DAY_OF_MONTH: return day;        case DAY_OF_YEAR: return getDayOfYear();        case EPOCH_DAY: throw new UnsupportedTemporalTypeException("Invalid field 'EpochDay' for get() method, use getLong() instead");        case ALIGNED_WEEK_OF_MONTH: return ((day - 1) / 7) + 1;        case ALIGNED_WEEK_OF_YEAR: return ((getDayOfYear() - 1) / 7) + 1;        case MONTH_OF_YEAR: return month;        case PROLEPTIC_MONTH: throw new UnsupportedTemporalTypeException("Invalid field 'ProlepticMonth' for get() method, use getLong() instead");        case YEAR_OF_ERA: return (year >= 1 ? year : 1 - year);        case YEAR: return year;        case ERA: return (year >= 1 ? 1 : 0);    }    throw new UnsupportedTemporalTypeException("Unsupported field: " + field);}

看完了日期的处理再看一下时间的吧,其实大同小异了。

时间的getLong方法。同样的经过判断走到get0里面,注意这是时间的getLongget0

@Overridepublic long getLong(TemporalField field) {    if (field instanceof ChronoField) {        if (field == NANO_OF_DAY) {            return toNanoOfDay();        }        if (field == MICRO_OF_DAY) {            return toNanoOfDay() / 1000;        }        return get0(field);    }    return field.getFrom(this);}

时间的get0方法。处理的就是这些类型了。主要看我们关注的几个

  • H 也就是 HOUR_OF_DAY, 直接返回时间的 hour
  • m 也就是MINUTE_OF_HOUR,直接返回时间的 minute
  • s 也就是 SECOND_OF_MINUTE, 直接返回时间的 second
private int get0(TemporalField field) {    switch ((ChronoField) field) {        case NANO_OF_SECOND: return nano;        case NANO_OF_DAY: throw new UnsupportedTemporalTypeException("Invalid field 'NanoOfDay' for get() method, use getLong() instead");        case MICRO_OF_SECOND: return nano / 1000;        case MICRO_OF_DAY: throw new UnsupportedTemporalTypeException("Invalid field 'MicroOfDay' for get() method, use getLong() instead");        case MILLI_OF_SECOND: return nano / 1000_000;        case MILLI_OF_DAY: return (int) (toNanoOfDay() / 1000_000);        case SECOND_OF_MINUTE: return second;        case SECOND_OF_DAY: return toSecondOfDay();        case MINUTE_OF_HOUR: return minute;        case MINUTE_OF_DAY: return hour * 60 + minute;        case HOUR_OF_AMPM: return hour % 12;        case CLOCK_HOUR_OF_AMPM: int ham = hour % 12; return (ham % 12 == 0 ? 12 : ham);        case HOUR_OF_DAY: return hour;        case CLOCK_HOUR_OF_DAY: return (hour == 0 ? 24 : hour);        case AMPM_OF_DAY: return hour / 12;    }    throw new UnsupportedTemporalTypeException("Unsupported field: " + field);}

总结

好了,到这里我们知道了时间格式的各种使用方法和格式化的源码。

对于不同格式化的区别。总结一下。

  • y 处理简单,只是判断了year > 1 就返回了year。
  • Y 处理较复杂,还判断了周,根据情况对年份+1和-1。某些年份的某些日期会有坑。一定要注意!!!
  • Md Hms处理非常简单,直接返回了日期时间上面对应的数。
  • -: 一些特殊字符,格式化的时候是直接增加到字符串里面的。

下面总结一下源码对应文件和方法的追踪链。感兴趣的可以自己在多翻翻源码。

ofPattern指定格式的调用链

  • DateTimeFormatter.java -> public static DateTimeFormatter ofPattern(String pattern)
    • DateTimeFormatterBuilder.java -> public DateTimeFormatterBuilder appendPattern(String pattern)
    • DateTimeFormatterBuilder.java -> private void parsePattern(String pattern)
    • DateTimeFormatterBuilder.java -> private void parseField(char cur, int count, TemporalField field)
    • DateTimeFormatterBuilder.java -> public DateTimeFormatterBuilder appendValue(TemporalField field, int width)
    • 在这里创建的解析器
    • DateTimeFormatterBuilder.java -> static class NumberPrinterParser implements DateTimePrinterParser
    • DateTimeFormatterBuilder.java -> static final class CharLiteralPrinterParser implements DateTimePrinterParser

format方法调用链

  • LocalDateTime.java -> public String format(DateTimeFormatter formatter)
    • DateTimeFormatter.java -> public String format(TemporalAccessor temporal)
    • DateTimeFormatter.java -> public void formatTo(TemporalAccessor temporal, Appendable appendable)
      • 接下来根据不同的处理解析器进行处理,主要有两个解析器
      • DateTimeFormatterBuilder.java -> static class NumberPrinterParser implements DateTimePrinterParser
      • DateTimeFormatterBuilder.java -> static final class CharLiteralPrinterParser implements DateTimePrinterParser
        • DateTimePrintContext.java -> Long getValue(TemporalField field)
          • LocalDateTime.java -> public long getLong(TemporalField field)
            • 这里日期调日期的 LocalDate.java -> public long getLong(TemporalField field)
            • LocalDate.java -> private int get0(TemporalField field)
            • 时间调时间的 LocalTime.java -> public long getLong(TemporalField field)
            • LocalTime.java -> private int get0(TemporalField field)