Java DateFormat inférieur vs supérieur

introduction

DateTimeFormatter de Java utilise les caractères alphabétiques demi-largeur fixes pour décider du type de chaîne de caractères à utiliser. Parmi eux, il existe de nombreuses chaînes de caractères telles que «y» et «Y» qui essaient d'exprimer des choses différentes uniquement par la différence entre les majuscules et les minuscules. Voici un résumé des différences.

environnement

Peut-être qu'il n'y a pas de différence de version avec Java, mais j'utilise Java 11. Jshell est utile pour dessiner du code court comme cette fois-ci, donc je l'essaye sur JShell.

Après le démarrage, importez la classe que vous utiliserez,.

tasogarei $ jshell
|Bienvenue dans JShell--Version 11.0.1
|Pour un aperçu, tapez: /help intro

jshell> import java.time.*

jshell> import java.time.format.DateTimeFormatter

g vs G «g» indique le trajet de Julius, et «G» indique l'ère.

jshell> LocalDateTime.now().format(DateTimeFormatter.ofPattern("g"));
$83 ==> "58499"

jshell> LocalDateTime.now().format(DateTimeFormatter.ofPattern("G"));
$84 ==> "UN D"

Si vous voulez en savoir plus sur Julius qui se rend au Japon, veuillez consulter Wikipedia (j'ai aussi appris pour la première fois) https://ja.wikipedia.org/wiki/%E3%83%A6%E3%83%AA%E3%82%A6%E3%82%B9%E9%80%9A%E6%97%A5

m vs M C'est simple: «m» signifie minutes et «M» signifie mois. Si vous en chevauchez deux de chaque, il renverra une chaîne avec un remplissage de 0 dans le cas d'un chiffre, donc si vous voulez avoir le même nombre de chiffres, il est courant d'en écrire deux. Dans les deux cas, le nombre de chiffres à exprimer est de 2 chiffres maximum, donc si vous écrivez 3 chiffres, une erreur se produira lors de l'exécution.

jshell> LocalDateTime.of(2019,12,12,12,1,1).format(DateTimeFormatter.ofPattern("mmm"));
|Exception java.lang.IllegalArgumentException: Too many pattern letters: m
|        at DateTimeFormatterBuilder.parseField (DateTimeFormatterBuilder.java:1952)
|        at DateTimeFormatterBuilder.parsePattern (DateTimeFormatterBuilder.java:1734)
|        at DateTimeFormatterBuilder.appendPattern (DateTimeFormatterBuilder.java:1702)
|        at DateTimeFormatter.ofPattern (DateTimeFormatter.java:564)
|        at (#24:1)

Cependant, comme «M» dépend de la situation, il peut en fait être plus correct d'utiliser «L». Puisque «L» est une méthode autonome, la même valeur est toujours affichée. Cependant, seule cette différence concerne SimpleDateFormat, et les deux peuvent être utilisés sans problème lors de l'utilisation de DateTimeFormatter.

d vs D Cela semble avoir une signification similaire et se comporte différemment.

Tout d'abord, il s'agit de «d», mais il affiche la date du mois sous la forme «jour du mois» dans l'explication. C'est la date que nous utilisons couramment.

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("dd"));
$3 ==> "02"

D'autre part, «D» est «jour de l'année», qui affiche la date basée sur l'année. C'est le nombre de jours depuis le 1er janvier, le début de l'année.

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("DDD"));
$4 ==> "033"

y vs Y Avant de regarder la différence entre les deux, examinons les résultats du code pour voir que le format d'affichage diffère en fonction du nombre spécifié. En général, je pense que vous allez soit spécifier deux et spécifier les deux derniers chiffres ou quatre et les afficher tous. Je ne pense pas qu'il y ait beaucoup de cas où des années autres que 4 chiffres sont affichées, donc ici nous ne regarderons que 4 chiffres.

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("y"));
$5 ==> "2019"

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("yy"));
$6 ==> "19"

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("yyy"));
$7 ==> "2019"

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("yyyy"));
$8 ==> "2019"

Puisque le «Y» majuscule est également utilisé pour exprimer l'année, il n'y a pas de changement dans la spécification du nombre.

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("Y"));
$9 ==> "2019"

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("YY"));
$10 ==> "19"

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("YYY"));
$11 ==> "2019"

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("YYYY"));
$12 ==> "2019"

Et la différence est de commencer par jeter un œil au code ci-dessous.

jshell> LocalDate.of(2018,12,30).format(DateTimeFormatter.ofPattern("YYYY"));
$44 ==> "2019"

jshell> LocalDate.of(2018,12,30).format(DateTimeFormatter.ofPattern("yyyy"));
$45 ==> "2018"

Même si j'ai spécifié la même date, l'année est décalée d'un an. C'est la différence, car «Y» sert à afficher l'année par calendrier grégorien et «y» à afficher l'année de l'ère, donc la différence apparaît. Pour le calendrier grégorien, consultez JavaDoc, mais c'est une bonne idée de garder à l'esprit qu'il est possible que les vacances de fin d'année et du nouvel an soient désactivées. Par conséquent, cela peut être un foyer pour intégrer un bogue qui semble passer simplement en testant que l'affichage de l'année est incorrect pendant seulement quelques jours pendant les vacances de fin d'année et du Nouvel An. Il ne fait aucun doute que je l'avais fait il y a longtemps et que j'ai passé un très mauvais moment.

Au fait, «y» affiche l'année de l'ère, donc ce n'est peut-être pas la valeur que vous attendiez, sauf si l'ère est dans le calendrier occidental. Par défaut, l'ère est le calendrier occidental (je ne l'ai pas confirmé jusqu'à ce que j'ai changé la locale).

jshell> LocalDate.of(2018,12,30).format(DateTimeFormatter.ofPattern("G"));
$46 ==> "UN D"

Je ne pense pas que ce soit un gros problème, mais pour être précis, ʻu est utilisé pour afficher l'année telle qu'elle est, donc utiliser ʻu peut être la bonne réponse. Je pense que cela dépend de la façon de penser, donc je ne peux rien dire.

jshell> LocalDate.of(2018,12,30).format(DateTimeFormatter.ofPattern("u"));
$47 ==> "2018"

k contre K et h contre H

«k» et «K», «h» et «H» affichent l'heure, mais ceux qui les affichent sont différents. Le tableau ci-dessous résume ce qui est affiché pour chacun.

Il y a une grande différence que les minuscules sont écrites à 24 heures et les majuscules à 12 heures.

w vs W «W» et «W» sont des expressions similaires pour la semaine, mais ont des critères différents. La différence est que «w» affiche le nombre de tours du mois pour «W» de l'année.

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("W"));
$55 ==> "1"

jshell> LocalDate.of(2019,2,2).format(DateTimeFormatter.ofPattern("w"));
$56 ==> "5"

s vs S «s» représente une seconde générale, tandis que «S» représente une «fraction de seconde».

jshell> LocalDateTime.now().format(DateTimeFormatter.ofPattern("s"));
$57 ==> "24"

jshell> LocalDateTime.now().format(DateTimeFormatter.ofPattern("S"));
$58 ==> "7"

Je ne comprends pas vraiment S, alors j'en ai spécifié plus d'un et j'ai regardé la différence de fonctionnement.

jshell> LocalDateTime.of(2019,1,1,0,0,12,10);
$75 ==> 2019-01-01T00:00:12.000000010

jshell> LocalDateTime.of(2019,1,1,0,0,12,10).format(DateTimeFormatter.ofPattern("SSS"));
$76 ==> "000"

jshell> LocalDateTime.of(2019,1,1,0,0,12,10).format(DateTimeFormatter.ofPattern("SSSS"));
$77 ==> "0000"

jshell> LocalDateTime.of(2019,1,1,0,0,12,10).format(DateTimeFormatter.ofPattern("SSSSS"));
$78 ==> "00000"

jshell> LocalDateTime.of(2019,1,1,0,0,12,10).format(DateTimeFormatter.ofPattern("SSSSSS"));
$79 ==> "000000"

jshell> LocalDateTime.of(2019,1,1,0,0,12,10).format(DateTimeFormatter.ofPattern("SSSSSSS"));
$80 ==> "0000000"

jshell> LocalDateTime.of(2019,1,1,0,0,12,10).format(DateTimeFormatter.ofPattern("SSSSSSSS"));
$81 ==> "00000001"

jshell> LocalDateTime.of(2019,1,1,0,0,12,10).format(DateTimeFormatter.ofPattern("SSSSSSSSS"));
$82 ==> "000000010"

Apparemment, il semble afficher combien de chiffres sont inférieurs à une seconde. C'est un niveau qui peut être finalement discriminé en spécifiant 10 nanosecondes en spécifiant «de» et en voyant la différence de fonctionnement.

q vs Q «q» et «Q» sont rarement synonymes du nombre de fois par trimestre. Je ne sais pas pourquoi tant de lettres ont des significations différentes, mais elles sont toutes identiques.

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("q"));
$87 ==> "4"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("Q"));
$88 ==> "4"

e vs E ʻE montre le jour localisé et ʻE montre le jour général.

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("E"));
$96 ==> "Feu"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("e"));
$97 ==> "3"

ʻE et ʻE ont un comportement intéressant que l'affichage change en fonction du nombre spécifié, alors essayez de changer le nombre spécifié.

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("ee"));
$101 ==> "03"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("eee"));
$102 ==> "Feu"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("eeee"));
$103 ==> "Mardi"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("eeeee"));
$104 ==> "Feu"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("eeeeee"));
|Exception java.lang.IllegalArgumentException: Too many pattern letters: e
|        at DateTimeFormatterBuilder.parseField (DateTimeFormatterBuilder.java:1903)
|        at DateTimeFormatterBuilder.parsePattern (DateTimeFormatterBuilder.java:1734)
|        at DateTimeFormatterBuilder.appendPattern (DateTimeFormatterBuilder.java:1702)
|        at DateTimeFormatter.ofPattern (DateTimeFormatter.java:564)
|        at (#105:1)

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("EE"));
$108 ==> "Feu"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("EEE"));
$109 ==> "Feu"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("EEEE"));
$110 ==> "Mardi"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("EEEEE"));
$111 ==> "Feu"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("EEEEEE"));
|Exception java.lang.IllegalArgumentException: Too many pattern letters: E
|        at DateTimeFormatterBuilder.parseField (DateTimeFormatterBuilder.java:1903)
|        at DateTimeFormatterBuilder.parsePattern (DateTimeFormatterBuilder.java:1734)
|        at DateTimeFormatterBuilder.appendPattern (DateTimeFormatterBuilder.java:1702)
|        at DateTimeFormatter.ofPattern (DateTimeFormatter.java:564)
|        at (#112:1)

Au fait, je n'étais pas sûr du cas où l'affichage des jours localisés et des jours généraux a changé.

A propos, on dit que c est affiché de la même manière que ʻe`, mais si vous en spécifiez deux ou plus, une erreur se produira. Il semble que le type de «c» gère les nombres avec des nombres et «e» gère les chaînes avec du texte.

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("c"));
$113 ==> "3"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("cc"));
|Exception java.lang.IllegalArgumentException: Invalid pattern "cc"
|        at DateTimeFormatterBuilder.parseField (DateTimeFormatterBuilder.java:1867)
|        at DateTimeFormatterBuilder.parsePattern (DateTimeFormatterBuilder.java:1734)
|        at DateTimeFormatterBuilder.appendPattern (DateTimeFormatterBuilder.java:1702)
|        at DateTimeFormatter.ofPattern (DateTimeFormatter.java:564)
|        at (#114:1)

Notez également que ʻe et cne sont pas définis dansSimpleDateFormatter et apparaissent à partir de DateTimeFormatter`.

jshell> new SimpleDateFormat("E").format(new Date())
$144 ==> "eau"

jshell> new SimpleDateFormat("e").format(new Date())
|Exception java.lang.IllegalArgumentException: Illegal pattern character 'e'
|        at SimpleDateFormat.compile (SimpleDateFormat.java:845)
|        at SimpleDateFormat.initialize (SimpleDateFormat.java:653)
|        at SimpleDateFormat.<init> (SimpleDateFormat.java:624)
|        at SimpleDateFormat.<init> (SimpleDateFormat.java:599)
|        at (#145:1)

jshell> new SimpleDateFormat("c").format(new Date())
|Exception java.lang.IllegalArgumentException: Illegal pattern character 'c'
|        at SimpleDateFormat.compile (SimpleDateFormat.java:845)
|        at SimpleDateFormat.initialize (SimpleDateFormat.java:653)
|        at SimpleDateFormat.<init> (SimpleDateFormat.java:624)
|        at SimpleDateFormat.<init> (SimpleDateFormat.java:599)
|        at (#146:1)

a vs A «A» représente le matin et l'après-midi de la journée, et «A» représente le nombre de ms écoulées dans la journée.

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("a"));
$147 ==> "un m."

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("A"));
$148 ==> "12000"

n VS N «n» représente la partie nanoseconde du temps et «N» représente le nombre de ns écoulés dans la journée.

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("n"));
$149 ==> "10"

jshell> LocalDateTime.of(2019,10,1,0,0,12,10).format(DateTimeFormatter.ofPattern("N"));
$150 ==> "12000000010"

v vs V «v» représente un nom de fuseau horaire générique et «V» représente un ID de fuseau horaire. Comme pour «V», s'il n'y en a qu'un, une erreur se produira, vous devez donc en spécifier deux comme «VV».

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("v"));
$159 ==> "GMT+09:00"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("VV"));
$160 ==> "Asia/Tokyo"

Puisque ceux-ci veulent exprimer le fuseau horaire, une erreur se produira dans le système LocalDate qui n'a pas le concept de fuseau horaire. La prudence est de mise.

jshell> LocalDateTime.now().format(DateTimeFormatter.ofPattern("VV"));
|Exception java.time.DateTimeException: Unable to extract ZoneId from temporal 2019-01-16T17:33:36.488440
|        at DateTimePrintContext.getValue (DateTimePrintContext.java:289)
|        at DateTimeFormatterBuilder$ZoneIdPrinterParser.format (DateTimeFormatterBuilder.java:4170)
|        at DateTimeFormatterBuilder$CompositePrinterParser.format (DateTimeFormatterBuilder.java:2335)
|        at DateTimeFormatter.formatTo (DateTimeFormatter.java:1843)
|        at DateTimeFormatter.format (DateTimeFormatter.java:1817)
|        at LocalDateTime.format (LocalDateTime.java:1752)
|        at (#161:1)

jshell> LocalDateTime.now().format(DateTimeFormatter.ofPattern("v"));
|Exception java.time.DateTimeException: Unable to extract ZoneId from temporal 2019-01-16T17:33:39.394345
|        at DateTimePrintContext.getValue (DateTimePrintContext.java:289)
|        at DateTimeFormatterBuilder$ZoneTextPrinterParser.format (DateTimeFormatterBuilder.java:4066)
|        at DateTimeFormatterBuilder$CompositePrinterParser.format (DateTimeFormatterBuilder.java:2335)
|        at DateTimeFormatter.formatTo (DateTimeFormatter.java:1843)
|        at DateTimeFormatter.format (DateTimeFormatter.java:1817)
|        at LocalDateTime.format (LocalDateTime.java:1752)
|        at (#162:1)

À propos, «JapaneseDate», qui indique la date au Japon, provoque également une erreur.

jshell> import java.time.chrono.*

jshell> JapaneseDate.now().format(DateTimeFormatter.ofPattern("v"));
|Exception java.time.DateTimeException: Unable to extract ZoneId from temporal Japanese Heisei 31-01-16
|        at DateTimePrintContext.getValue (DateTimePrintContext.java:289)
|        at DateTimeFormatterBuilder$ZoneTextPrinterParser.format (DateTimeFormatterBuilder.java:4066)
|        at DateTimeFormatterBuilder$CompositePrinterParser.format (DateTimeFormatterBuilder.java:2335)
|        at DateTimeFormatter.formatTo (DateTimeFormatter.java:1843)
|        at DateTimeFormatter.format (DateTimeFormatter.java:1817)
|        at ChronoLocalDate.format (ChronoLocalDate.java:642)
|        at (#164:1)

jshell> JapaneseDate.now().format(DateTimeFormatter.ofPattern("VV"));
|Exception java.time.DateTimeException: Unable to extract ZoneId from temporal Japanese Heisei 31-01-16
|        at DateTimePrintContext.getValue (DateTimePrintContext.java:289)
|        at DateTimeFormatterBuilder$ZoneIdPrinterParser.format (DateTimeFormatterBuilder.java:4170)
|        at DateTimeFormatterBuilder$CompositePrinterParser.format (DateTimeFormatterBuilder.java:2335)
|        at DateTimeFormatter.formatTo (DateTimeFormatter.java:1843)
|        at DateTimeFormatter.format (DateTimeFormatter.java:1817)
|        at ChronoLocalDate.format (ChronoLocalDate.java:642)
|        at (#165:1)

z vs Z «z» représente le nom du fuseau horaire et «Z» représente le décalage de zone. Je pensais que cela causerait une situation grave si je commençais à parler de choses qui ne sont généralement pas liées, alors je les omettrai ici.

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("z"));
$166 ==> "JST"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("Z"));
$167 ==> "+0900"

L'affichage de «z» et «Z» change également en fonction du nombre spécifié, je voudrais donc le spécifier.

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("z"));
$174 ==> "JST"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("zz"));
$175 ==> "JST"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("zzz"));
$176 ==> "JST"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("zzzz"));
$177 ==> "Heure standard japonaise"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("zzzzz"));
|Exception java.lang.IllegalArgumentException: Too many pattern letters: z
|        at DateTimeFormatterBuilder.parsePattern (DateTimeFormatterBuilder.java:1737)
|        at DateTimeFormatterBuilder.appendPattern (DateTimeFormatterBuilder.java:1702)
|        at DateTimeFormatter.ofPattern (DateTimeFormatter.java:564)
|        at (#178:1)

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("Z"));
$180 ==> "+0900"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("ZZ"));
$181 ==> "+0900"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("ZZZ"));
$182 ==> "+0900"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("ZZZZ"));
$183 ==> "GMT+09:00"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("ZZZZZ"));
$184 ==> "+09:00"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("ZZZZZZ"));
|Exception java.lang.IllegalArgumentException: Too many pattern letters: Z
|        at DateTimeFormatterBuilder.parsePattern (DateTimeFormatterBuilder.java:1764)
|        at DateTimeFormatterBuilder.appendPattern (DateTimeFormatterBuilder.java:1702)
|        at DateTimeFormatter.ofPattern (DateTimeFormatter.java:564)
|        at (#185:1)

Notez que «z» et «Z» se comportent différemment de «SimpleDateFormatter».

jshell> new SimpleDateFormat("Z").format(new Date());
$219 ==> "+0900"

jshell> new SimpleDateFormat("ZZ").format(new Date());
$220 ==> "+0900"

jshell> new SimpleDateFormat("ZZZ").format(new Date());
$221 ==> "+0900"

jshell> new SimpleDateFormat("ZZZZ").format(new Date());
$222 ==> "+0900"

jshell> new SimpleDateFormat("ZZZZZ").format(new Date());
$223 ==> "+0900"

jshell> new SimpleDateFormat("ZZZZZZ").format(new Date());
$224 ==> "+0900"

jshell> new SimpleDateFormat("z").format(new Date());
$210 ==> "JST"

jshell> new SimpleDateFormat("zz").format(new Date());
$211 ==> "JST"

jshell> new SimpleDateFormat("zzz").format(new Date());
$212 ==> "JST"

jshell> new SimpleDateFormat("zzzz").format(new Date());
$213 ==> "Heure standard japonaise"

jshell> new SimpleDateFormat("zzzzz").format(new Date());
$214 ==> "Heure standard japonaise"

jshell> new SimpleDateFormat("zzzzzz").format(new Date());
$215 ==> "Heure standard japonaise"

jshell> new SimpleDateFormat("zzzzzzz").format(new Date());
$216 ==> "Heure standard japonaise"

jshell> new SimpleDateFormat("zzzzzzzz").format(new Date());
$217 ==> "Heure standard japonaise"

Au fait, j'ai essayé de spécifier le nombre, mais aucune erreur ne s'est produite.

x vs X Les deux «x» et «X» représentent le décalage de zone, qui semble se comporter de la même manière sauf pour UTC. La seule différence avec «Z» est que l'affichage change lorsque 1 et 4 sont spécifiés.

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("x"));
$186 ==> "+09"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("X"));
$187 ==> "+09

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("x"));
$188 ==> "+09"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("xx"));
$189 ==> "+0900"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("xxx"));
$190 ==> "+09:00"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("xxxx"));
$191 ==> "+0900"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("xxxxx"));
$192 ==> "+09:00"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("xxxxxx"));
|Exception java.lang.IllegalArgumentException: Too many pattern letters: x
|        at DateTimeFormatterBuilder.parsePattern (DateTimeFormatterBuilder.java:1781)
|        at DateTimeFormatterBuilder.appendPattern (DateTimeFormatterBuilder.java:1702)
|        at DateTimeFormatter.ofPattern (DateTimeFormatter.java:564)
|        at (#193:1)

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("X"));
$194 ==> "+09"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("XX"));
$195 ==> "+0900"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("XXX"));
$196 ==> "+09:00"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("XXXX"));
$197 ==> "+0900"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("XXXXX"));
$198 ==> "+09:00"

jshell> ZonedDateTime.now().format(DateTimeFormatter.ofPattern("XXXXXX"));
|Exception java.lang.IllegalArgumentException: Too many pattern letters: X
|        at DateTimeFormatterBuilder.parsePattern (DateTimeFormatterBuilder.java:1776)
|        at DateTimeFormatterBuilder.appendPattern (DateTimeFormatterBuilder.java:1702)
|        at DateTimeFormatter.ofPattern (DateTimeFormatter.java:564)
|        at (#199:1)

Au fait, «x» n'existe pas dans «SimpleDateFormatter», seulement «DateTimeFormatter».

jshell> new SimpleDateFormat("x").format(new Date());
|Exception java.lang.IllegalArgumentException: Illegal pattern character 'x'
|        at SimpleDateFormat.compile (SimpleDateFormat.java:845)
|        at SimpleDateFormat.initialize (SimpleDateFormat.java:653)
|        at SimpleDateFormat.<init> (SimpleDateFormat.java:624)
|        at SimpleDateFormat.<init> (SimpleDateFormat.java:599)
|        at (#205:1)

Notez que le comportement de «X» est également différent.

jshell> new SimpleDateFormat("X").format(new Date());
$206 ==> "+09"

jshell> new SimpleDateFormat("XX").format(new Date());
$207 ==> "+0900"

jshell> new SimpleDateFormat("XXX").format(new Date());
$208 ==> "+09:00"

jshell> new SimpleDateFormat("XXXX").format(new Date());
|Exception java.lang.IllegalArgumentException: invalid ISO 8601 format: length=4
|        at SimpleDateFormat.encode (SimpleDateFormat.java:884)
|        at SimpleDateFormat.compile (SimpleDateFormat.java:865)
|        at SimpleDateFormat.initialize (SimpleDateFormat.java:653)
|        at SimpleDateFormat.<init> (SimpleDateFormat.java:624)
|        at SimpleDateFormat.<init> (SimpleDateFormat.java:599)
|        at (#209:1)

Vous ne serez pas au courant de la différence qui se produit uniquement en UTC car il affiche généralement l'heure en JST, mais je pense que vous devriez simplement vous rappeler de faire attention à UTC. Je l'ai finalement compris en regardant la mise en œuvre.

jshell> ZonedDateTime.of(2019,1,1,1,1,1,1,ZoneId.of(ZoneOffset.UTC.toString())).format(DateTimeFormatter.ofPattern("X"));
$228 ==> "Z"

jshell> ZonedDateTime.of(2019,1,1,1,1,1,1,ZoneId.of(ZoneOffset.UTC.toString())).format(DateTimeFormatter.ofPattern("x"));
$229 ==> "+00"

à la fin

Cela s'est avéré plus effrayant que ce à quoi je m'attendais car il y a de nombreux points où le comportement est différent de SimpleDateFormatter et le fuseau horaire est suspect. Pour être honnête, je ne l'ai pas beaucoup utilisé, donc je ne sais pas ce qui est juste pour le moment, mais si j'ai le temps, j'aimerais voir l'implémentation du côté Java.