How to Convert a String to a Date in Java

By the end of this page, you will understand how to parse a human-readable date string such as "January 2, 2010" in Java, why manually setting fields on Date is not the best approach, and how to use the modern Java date-time API to safely extract year, month, and day or convert the result to a timestamp when needed.

Java date parsing means converting text like "January 2, 2010" into a structured date object that Java can understand.

The key idea is that a date string is just text until you tell Java what pattern it follows. In this case:

• January is the full month name
• 2 is the day of the month
• 2010 is the year

So Java needs a formatter pattern that matches that shape.

In older Java code, developers often used java.util.Date and SimpleDateFormat. That works, but modern Java prefers the java.time package introduced in Java 8.

Why this matters:

• Parsing lets your program accept user input or file data.
• Structured date objects are safer than manually splitting strings.
• Modern APIs avoid many bugs found in older Date methods.

Important note: methods like Date#setMonth(), Date#setYear(), and similar older setters are considered outdated and confusing. They have odd behavior, such as zero-based months and year offsets in some cases. In real Java code, you should usually parse into LocalDate first, then convert only if needed.

Think of a date formatter like a reading template.

If someone gives you the text "January 2, 2010", you need instructions that say:

• first read a full month name
• then read a day number
• then read a 4-digit year

Without that template, Java just sees a plain string.

A good mental model is:

• String = raw label on a box
• Date/LocalDate = the actual organized contents
• Formatter = the instructions for opening and arranging the contents correctly

So you do not manually build the date piece by piece unless you really need to. Usually, you let the formatter read the whole string for you.

The modern Java approach uses LocalDate and DateTimeFormatter.

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        String input = "January 2, 2010";

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);
        LocalDate date = LocalDate.parse(input, formatter);

        int month = date.getMonthValue();
        int day = date.getDayOfMonth();
        int year = date.getYear();

        System.out.println(date);   // 2010-01-02
        System.out.println(month);  // 1
        System.out.println(day);    // 2
        System.out.println(year);   // 2010
    }
}

Consider this example:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        String input = "January 2, 2010";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);
        LocalDate date = LocalDate.parse(input, formatter);

        System.out.println(date.getYear());
        System.out.println(date.getMonthValue());
        System.out.println(date.getDayOfMonth());
    }
}

What happens step by step:

1. input stores the raw text: "January 2, 2010".
2. DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH) creates parsing rules.
   • MMMM expects a full month name.
   • d expects the day number.
   • yyyy expects the year.

Date parsing is common in many kinds of Java programs:

• Web forms: a user enters a date like January 2, 2010
• CSV imports: a file contains date columns as text
• APIs: incoming JSON or query parameters contain dates as strings
• Reports: analytics tools convert text dates into sortable values
• Scheduling systems: appointments or deadlines start as human-readable strings

Examples:

• A payroll app parses employee start dates.
• A booking system parses check-in dates.
• A log processing script turns text dates into timestamps.
• A REST API validates and stores a birth date sent as a string.

In real projects, developers usually avoid manually calling old Date setter methods. Instead, they follow safer patterns.

Common patterns include:

• Parse once, use many times: convert the input string into a LocalDate immediately.
• Validation: reject invalid date strings early.
• Guard clauses: return an error if parsing fails.
• Conversion only at boundaries: use Date or timestamps only when interacting with legacy libraries or databases.
• Locale-aware parsing: specify Locale.ENGLISH when month names are written in English.

Example with validation:

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Locale;

public class DateParser {
    private static final DateTimeFormatter FORMATTER =
        DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);

    public static LocalDate parseDate(String input) {
        if (input ==  || input.isBlank()) {
              ();
        }

         {
             LocalDate.parse(input, FORMATTER);
        }  (DateTimeParseException e) {
              (, e);
        }
    }
}

Beginners often run into these problems when working with dates in Java.

1. Using old Date setter methods

Broken approach:

Date date = new Date();
date.setMonth(1);
date.setYear(2010);

Why it is a problem:

• Old Date setters are deprecated in practice.
• They are confusing and easy to misuse.
• Some values are offset or zero-based.

Better approach:

LocalDate date = LocalDate.of(2010, 1, 2);

2. Forgetting the locale for month names

Broken code:

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy");

Why it can fail:

• January is an English month name.
• If the system default locale is not English, parsing may fail.

Here is a comparison of common Java date options:

// Parse "January 2, 2010"
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);
LocalDate date = LocalDate.parse("January 2, 2010", formatter);

Pattern letters:

• MMMM = full month name (January)
• MMM = short month name (Jan)
• d = day of month (2)
• dd = day of month with leading zero (02)
• yyyy = 4-digit year (2010)

Extract values:

int year = date.getYear();
int month = date.getMonthValue();
int day = date.getDayOfMonth();

How do I parse January 2, 2010 in Java?

Use LocalDate.parse() with a DateTimeFormatter pattern of "MMMM d, yyyy" and Locale.ENGLISH.

Should I use Date or LocalDate in Java?

For new code, use LocalDate if you only need a calendar date. Use Date only for legacy compatibility.

Why does Java need Locale.ENGLISH here?

Because January is an English month name. Without the correct locale, parsing may fail on systems using another language.

How do I get the month, day, and year as integers?

Use:

int month = date.getMonthValue();
int day = date.getDayOfMonth();
int year = date.getYear();

How do I convert a parsed date to milliseconds?

• LocalDate - Represents a date without a time or time zone.
• DateTimeFormatter - Defines how strings are parsed into dates and formatted back to text.
• Locale - Affects parsing of month and day names written in human language.
• Instant - Represents a specific moment in time, useful for timestamps.
• ZoneId - Required when converting a calendar date into an exact instant.
• SimpleDateFormat - Older Java class for parsing and formatting dates in legacy code.
• java.util.Date - Legacy date class still seen when working with old libraries.
• LocalDateTime - Represents a date and time without a time zone.