How to convert different date formats in JDK11 to dd-mm-yyyy format?

Question

I have a use case where I have date in the following formats,

1. 2023-05-09T05:55:07Z
2. 2023-04-30
3. 08-05-2023
4. 2023-05-09 00:00:00
5. 31-Dec-2021

Irrespective of the input format I have a requirement to convert it to dd-mm-yyyy format. How can I convert it in JDK11? I tried different libraries but got no luck.

Answer 1

You can iterate over known formats and skip ones that throw a DateTimeParseException.

Note: If you are parsing just a date string into a LocalDateTime, you will need to build the formatter and specify that the time portion is optional.

import java.time.LocalDateTime;
import java.time.format.*;
import java.time.temporal.ChronoField;
import java.util.*;

public class DateParser {
    public static void main(String[] args) {
        System.out.println(normalizeDate("2023-05-09T05:55:07Z")); // 2023-05-09
        System.out.println(normalizeDate("2023-04-30")); // 2023-04-30
        System.out.println(normalizeDate("08-05-2023")); // 2023-08-05
        System.out.println(normalizeDate("2023-05-09 00:00:00")); // 2023-05-09
        System.out.println(normalizeDate("31-Dec-2021")); // 2021-12-31
        System.out.println(normalizeDate("")); // null
    }

    public static String normalizeDate(String rawDateTimeString) {
        return Optional.ofNullable(parseDateString(rawDateTimeString))
                .map(displayFormat::format)
                .orElse(null);
    }

    private static LocalDateTime parseDateString(String dateString) {
        for (DateTimeFormatter formatter : knownFormats) {
            try {
                return LocalDateTime.parse(dateString, formatter);
            } catch (DateTimeParseException e) {
                continue;
            }
        }
        return null;
    }

    private static final List<DateTimeFormatter> knownFormats = Arrays.asList(
            DateTimeFormatter.ISO_DATE_TIME,
            dateOnlyFormatter("yyyy-MM-dd"),
            dateOnlyFormatter("MM-dd-yyyy"),
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
            dateOnlyFormatter("dd-MMM-yyyy").withLocale(Locale.ENGLISH));

    private static DateTimeFormatter dateOnlyFormatter(String datePattern) {
        // Credit: https://stackoverflow.com/a/40175568/1762224
        return new DateTimeFormatterBuilder()
                .appendPattern(datePattern)
                .optionalStart()
                .appendPattern(" HH:mm")
                .optionalEnd()
                .parseDefaulting(ChronoField.HOUR_OF_DAY, 0)
                .parseDefaulting(ChronoField.MINUTE_OF_HOUR, 0)
                .toFormatter();
    }

    private static final DateTimeFormatter displayFormat = DateTimeFormatter.ISO_DATE;
}

Here is a modified version that is simpler as Devin suggested. It ignores the concept of time entirely, and only focuses on date when parsing. It removes the need for the dateOnlyFormatter method (as seen above).

import java.time.LocalDate;
import java.time.format.*;
import java.util.*;

public class DateParser {
    public static void main(String[] args) {
        System.out.println(normalizeDate("2023-05-09T05:55:07Z")); // 2023-05-09
        System.out.println(normalizeDate("2023-04-30")); // 2023-04-30
        System.out.println(normalizeDate("08-05-2023")); // 2023-08-05
        System.out.println(normalizeDate("2023-05-09 00:00:00")); // 2023-05-09
        System.out.println(normalizeDate("31-Dec-2021")); // 2021-12-31
        System.out.println(normalizeDate("")); // null
    }

    public static String normalizeDate(String rawDateTimeString) {
        return Optional.ofNullable(parseDateString(rawDateTimeString))
                .map(displayFormat::format)
                .orElse(null);
    }

    private static LocalDate parseDateString(String dateString) {
        for (DateTimeFormatter formatter : knownFormats) {
            try {
                return LocalDate.parse(dateString, formatter);
            } catch (DateTimeParseException e) {
                continue;
            }
        }
        return null;
    }

    private static final List<DateTimeFormatter> knownFormats = Arrays.asList(
            DateTimeFormatter.ISO_DATE_TIME,
            DateTimeFormatter.ofPattern("yyyy-MM-dd"),
            DateTimeFormatter.ofPattern("MM-dd-yyyy"),
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
            DateTimeFormatter.ofPattern("dd-MMM-yyyy").withLocale(Locale.ENGLISH));

    private static final DateTimeFormatter displayFormat = DateTimeFormatter.ISO_DATE;
}

Answer 2

This method is simple and easy to decipher. Here is all that the parseDateTime function does:

1. Sets the output format
2. Sets all possible input formats
3. Iterates over each input format until the correct one is found
4. Returns the date/time in the specified output format

Note If the String passed into the function is not in one of the 5 specified input formats, then it will return null. This should make it easy to see if it was successful or not!

If you need more information to help add more formats, here is the DateTimeFormatter Documentation: https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html#ISO_DATE

import java.time.*;
import java.time.format.DateTimeFormatter;

public class Main {
     public static void main(String[] args) {
        String[] inputDates = {
                "2023-04-30T05:55:07Z",
                "2023-04-30",
                "30-04-2023",
                "2023-04-30 00:00:00",
                "30-Apr-2023"
        };

        for(String date : inputDates)
            System.out.println(date + "\t->\t" + parseDateTime(date));
    }


    private static String parseDateTime(String currentDate){
        //Desired Output Pattern
        DateTimeFormatter outputFormat = DateTimeFormatter.ofPattern("dd-MM-yyyy");

        //All Possible Input Patterns
        DateTimeFormatter[] formatters = {
            DateTimeFormatter.ISO_LOCAL_DATE,
            DateTimeFormatter.ofPattern("dd-MM-yyyy"),
            DateTimeFormatter.ofPattern("dd-MMM-yyyy"),
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
            DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'")
        };

        //Iterate over each pattern until it finds the correct one
        for(DateTimeFormatter currFormatter : formatters){
            try{
                return LocalDate.parse(currentDate, currFormatter).format(outputFormat);
            } catch(Exception ignored){
                //Current formatter did not work, so lets try the next one
            }
        }
        return null; // String was not one of those 5 formats
    }
}```