# java.time.format

***

**1. Formatting a `LocalDateTime` as a String:**

```java
LocalDateTime now = LocalDateTime.now();
String formattedNow = now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
System.out.println(formattedNow);
```

**2. Parsing a `String` into a `LocalDateTime`:**

```java
String dateString = "2023-03-08T10:15:30";
LocalDateTime parsedDate = LocalDateTime.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
System.out.println(parsedDate);
```

**3. Customizing the Format Pattern:**

```java
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
String formattedDate = LocalDateTime.now().format(formatter);
System.out.println(formattedDate);
```

**4. Using a `Locale` for Localization:**

```java
Locale locale = Locale.FRANCE;
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy", locale);
String formattedDate = LocalDateTime.now().format(formatter);
System.out.println(formattedDate);
```

**5. Formatting a `ZonedDateTime` with an Offset:**

```java
ZonedDateTime zonedDateTime = ZonedDateTime.now();
String formattedZonedDateTime = zonedDateTime.format(DateTimeFormatter.RFC_1123_DATE_TIME);
System.out.println(formattedZonedDateTime);
```

**6. Parsing Date with Year-Only Precision:**

```java
String dateString = "2023";
Year parsedDate = Year.parse(dateString);
System.out.println(parsedDate);
```

**7. Formatting a `LocalDate` with Month Name:**

```java
LocalDate localDate = LocalDate.now();
String formattedLocalDate = localDate.format(DateTimeFormatter.ofPattern("dd MMMM yyyy"));
System.out.println(formattedLocalDate);
```

**8. Parsing Time with Millisecond Precision:**

```java
String timeString = "10:15:30.123";
LocalTime parsedTime = LocalTime.parse(timeString, DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
System.out.println(parsedTime);
```

**9. Formatting a `LocalDate` with Era:**

```java
LocalDate localDate = LocalDate.now();
String formattedLocalDate = localDate.format(DateTimeFormatter.ofPattern("G yyyy-MM-dd"));
System.out.println(formattedLocalDate);
```

**10. Parsing Date and Time with Fractional Seconds:**

```java
String dateTimeString = "2023-03-08T10:15:30.123456789";
LocalDateTime parsedDateTime = LocalDateTime.parse(dateTimeString, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
System.out.println(parsedDateTime);
```

**11. Printing a `LocalDateTime` in ISO 8601 Standard Format:**

```java
LocalDateTime localDateTime = LocalDateTime.now();
String formattedDateTime = localDateTime.format(DateTimeFormatter.ISO_8601);
System.out.println(formattedDateTime);
```

**12. Formatting a `LocalDate` as a Short Date:**

```java
LocalDate localDate = LocalDate.now();
String formattedLocalDate = localDate.format(DateTimeFormatter.SHORT_DATE);
System.out.println(formattedLocalDate);
```

**13. Parsing Time with Nanosecond Precision:**

```java
String timeString = "10:15:30.123456789";
LocalTime parsedTime = LocalTime.parse(timeString, DateTimeFormatter.ofPattern("HH:mm:ss.SSSSSSSSS"));
System.out.println(parsedTime);
```

**14. Formatting a `LocalDateTime` with a Different Time Zone:**

```java
ZoneId zoneId = ZoneId.of("America/New_York");
ZonedDateTime zonedDateTime = ZonedDateTime.now(zoneId);
String formattedDateTime = zonedDateTime.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME);
System.out.println(formattedDateTime);
```

**15. Parsing a `String` into a `LocalTime`:**

```java
String timeString = "10:15:30";
LocalTime parsedTime = LocalTime.parse(timeString, DateTimeFormatter.ofPattern("HH:mm:ss"));
System.out.println(parsedTime);
```

**16. Formatting a `ZonedDateTime` with Time Zone ID:**

```java
ZonedDateTime zonedDateTime = ZonedDateTime.now();
String formattedZonedDateTime = zonedDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS z"));
System.out.println(formattedZonedDateTime);
```

**17. Parsing Date and Time with Zone Offset:**

```java
String dateTimeString = "2023-03-08T10:15:30+01:00";
LocalDateTime parsedDateTime = LocalDateTime.parse(dateTimeString, DateTimeFormatter.ISO_OFFSET_DATE_TIME);
System.out.println(parsedDateTime);
```

**18. Formatting a `MonthDay`:**

```java
MonthDay monthDay = MonthDay.now();
String formattedMonthDay = monthDay.format(DateTimeFormatter.ofPattern("MMMM dd"));
System.out.println(formattedMonthDay);
```

**19. Parsing a `String` into a `Month`:**

```java
String monthString = "March";
Month parsedMonth = Month.parse(monthString);
System.out.println(parsedMonth);
```

**20. Formatting a `LocalDateTime` with a Custom Date Style:**

```java
LocalDateTime localDateTime = LocalDateTime.now();
String formattedDateTime = localDateTime.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
System.out.println(formattedDateTime);
```

**21. Parsing Time with Second Fraction:**

```java
String timeString = "10:15:30.123";
LocalTime parsedTime = LocalTime.parse(timeString, DateTimeFormatter.ofPattern("HH:mm:ss.S"));
System.out.println(parsedTime);
```

**22. Formatting a `ZonedDateTime` with milliseconds:**

```java
ZonedDateTime zonedDateTime = ZonedDateTime.now();
String formattedZonedDateTime = zonedDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));
System.out.println(formattedZonedDateTime);
```

**23. Parsing a `String` into a `YearMonth`:**

```java
String yearMonthString = "2023-03";
YearMonth parsedYearMonth = YearMonth.parse(yearMonthString);
System.out.println(parsedYearMonth);
```

**24. Formatting a `Period`:**

```java
Period period = Period.ofDays(10);
String formattedPeriod = period.format(PeriodFormatter.ofPattern("Pdd days"));
System.out.println(formattedPeriod);
```

**25. Parsing a `String` into a `Duration`:**

```java
String durationString = "PT10S";
Duration parsedDuration = Duration.parse(durationString);
System.out.println(parsedDuration);
```

**26. Formatting a `Duration` in Hours and Minutes:**

```java
Duration duration = Duration.ofHours(3).plusMinutes(30);
String formattedDuration = duration.toString().substring(2).replace("H", " hours, ");
System.out.println(formattedDuration);
```

**27. Parsing a `String` into a `DayOfWeek`:**

```java
String dayOfWeekString = "MONDAY";
DayOfWeek parsedDayOfWeek = DayOfWeek.valueOf(dayOfWeekString);
System.out.println(parsedDayOfWeek);
```

**28. Formatting a `ZonedDateTime` with a Specific Time Zone Display:**

```java
ZonedDateTime zonedDateTime = ZonedDateTime.now();
String formattedZonedDateTime = zonedDateTime.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss VV"));
System.out.println(formattedZonedDateTime);
```

**29. Parsing a `String` into an `Instant`:**

```java
String instantString = "2023-03-08T10:15:30Z";
Instant parsedInstant = Instant.parse(instantString);
System.out.println(parsedInstant);
```

**30. Formatting a `ZoneOffset`:**

```java
ZoneOffset zoneOffset = ZoneOffset.ofHours(5).plusMinutes(30);
String formattedZoneOffset = zoneOffset.toString().replace("Z", "");
System.out.println(formattedZoneOffset);
```

**31. Parsing a `String` into an `OffsetTime`:**

```java
String offsetTimeString = "10:15:30+05:30";
OffsetTime parsedOffsetTime = OffsetTime.parse(offsetTimeString);
System.out.println(parsedOffsetTime);
```

**32. Formatting a `Year`:**

```java
Year year = Year.of(2023);
String formattedYear = year.format(DateTimeFormatter.ofPattern("YYYY"));
System.out.println(formattedYear);
```

**33. Parsing a `String` into a `Quarter`:**

```java
String quarterString = "Q2";
Quarter parsedQuarter = Quarter.valueOf(quarterString);
System.out.println(parsedQuarter);
```

**34. Formatting a `Period` in Years and Months:**

```java
Period period = Period.ofYears(2).plusMonths(6);
String formattedPeriod = period.format(PeriodFormatter.ofPattern("PYY and MM"));
System.out.println(formattedPeriod);
```

**35. Parsing a `String` into a `TemporalAccessor`:**

```java
String temporalAccessorString = "2023-03-08T10:15:30";
TemporalAccessor parsedTemporalAccessor = DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(temporalAccessorString);
System.out.println(parsedTemporalAccessor);
```

**36. Formatting a `ZoneOffset` with Hours and Minutes:**

```java
ZoneOffset zoneOffset = ZoneOffset.ofHours(-5).plusMinutes(30);
String formattedZoneOffset = zoneOffset.toString().substring(1).replace("-", " hours ");
System.out.println(formattedZoneOffset);
```

**37. Parsing a `String` into a `ZoneRegion`:**

```java
String zoneRegionString = "America/New_York";
ZoneRegion parsedZoneRegion = ZoneRegion.of(zoneRegionString);
System.out.println(parsedZoneRegion);
```

**38. Formatting a `DateTimeException`:**

```java
try {
    LocalDateTime.parse("2023-03-09T24:00:00");
} catch (DateTimeException e) {
    System.out.println(e.getMessage());
}
```

**39. Parsing a `String` into a `ChronoUnit`:**

```java
String chronoUnitString = "YEARS";
ChronoUnit parsedChronoUnit = ChronoUnit.valueOf(chronoUnitString);
System.out.println(parsedChronoUnit);
```

**40. Formatting a `LocalDate` with Ordinal Date:**

```java
LocalDate localDate = LocalDate.now();
String formattedLocalDate = localDate.format(DateTimeFormatter.ofPattern("D"));
System.out.println(formattedLocalDate);
```

**41. Parsing a `String` into a `ChronoField`:**

```java
String chronoFieldString = "DAY_OF_MONTH";
ChronoField parsedChronoField = ChronoField.valueOf(chronoFieldString);
System.out.println(parsedChronoField);
```

**42. Formatting a `LocalTime` with Nanoseconds:**

```java
LocalTime localTime = LocalTime.now();
String formattedLocalTime = localTime.format(DateTimeFormatter.ofPattern("HH:mm:ss.SSSSSSSSS"));
System.out.println(formattedLocalTime);
```

**43. Parsing a `String` into a `WeekFields`:**

```java
String weekFieldsString = "SUNDAY_START";
WeekFields parsedWeekFields = WeekFields.of(Locale.US, WeekFields.SUNDAY_START);
System.out.println(parsedWeekFields);
```

**44. Formatting a `ZoneId`:**

```java
ZoneId zoneId = ZoneId.of("America/Los_Angeles");
String formattedZoneId = zoneId.toString();
System.out.println(formattedZoneId);
```

**45. Parsing a `String` into a `Chronology`:**

```java
String chronologyString = "ISO";
Chronology parsedChronology = Chronology.of(chronologyString);
System.out.println(parsedChronology);
```

**46. Formatting a `ZoneOffset` with Hours, Minutes, and Seconds:**

```java
ZoneOffset zoneOffset = ZoneOffset.ofTotalSeconds(18000);
String formattedZoneOffset = zoneOffset.toString().substring(1).replace('-', " hours ").replace(':', " minutes ");
System.out.println(formattedZoneOffset);
```

**47. Parsing a `String` into a `LocalDateTime` from a Unix Epoch:**

```java
String epochString = "1678394800";
LocalDateTime parsedDateTime = LocalDateTime.ofEpochSecond(Long.parseLong(epochString), 0, ZoneOffset.UTC);
System.out.println(parsedDateTime);
```

**48. Formatting a `DayOfWeek` in Full Form:**

```java
DayOfWeek dayOfWeek = DayOfWeek.MONDAY;
String formattedDayOfWeek = dayOfWeek.getDisplayName(TextStyle.FULL, Locale.US);
System.out.println(formattedDayOfWeek);
```

**49. Parsing a `String` into a `DateTimeFormatter`:**

```java
String formatterPattern = "yyyy-MM-dd HH:mm";
DateTimeFormatter parsedFormatter = DateTimeFormatter.ofPattern(formatterPattern);
System.out.println(parsedFormatter);
```

**50. Formatting a `Duration` in Minutes and Seconds:**

```java
Duration duration = Duration.ofMinutes(5).plusSeconds(30);
String formattedDuration = String.format("%d minutes %d seconds", duration.toMinutes(), duration.getSeconds());
System.out.println(formattedDuration);
```