Java String to Date

Last Updated : 8 Jan 2026

In Java, a string variable can be represented in the format of date. The task is to translate or change the String variable into date format. Let's understand in detail the various methods and approaches used for the conversion of a String variable into a date.

Example 1:

Input: String s = "2020-03-28T10:15:01Z"

Output: 2020-03-28T10:15:01Z

Explanation: The value stored in the string s variable is converted into a date format.

Example 2:

Input: String s = "2024-02-06T15:23:01Z"

Output: 2024-02-06T15:23:01Z

Methods to Convert String into Date

There are various methods and techniques that can be utilized for the conversion of a String value to a date format are as follows. Let us understand about them in detail.

Using SimpleDateFormat Classs
Using Instant Class
Using DateTimeFormatter Class
Using SimpleDateFormat Class

Using SimpleDateFormat.parse() Method

Let's see the simple code to convert String to Date in Java.

StringToDateExample1.java

import java.text.SimpleDateFormat;
import java.util.Date;
public class StringToDateExample1 {
public static void main(String[] args)throws Exception {
	String sDate1="31/12/1998";
	Date date1=new SimpleDateFormat("dd/MM/yyyy").parse(sDate1);
	System.out.println(sDate1+"\t"+date1);
}
}

Output:

31/12/1998	Thu Dec 31 00:00:00 IST 1998

Let's see another code to convert different types of Strings to Date in Java. Here, we have used different date formats using SimpleDateFormat class.

StringToDateExample2.java

import java.text.SimpleDateFormat;
import java.util.Date;
public class StringToDateExample2 {
public static void main(String[] args)throws Exception {
	String sDate1="31/12/1998";
    String sDate2 = "31-Dec-1998";
    String sDate3 = "12 31, 1998";
    String sDate4 = "Thu, Dec 31 1998";
    String sDate5 = "Thu, Dec 31 1998 23:37:50";
    String sDate6 = "31-Dec-1998 23:37:50";
    SimpleDateFormat formatter1=new SimpleDateFormat("dd/MM/yyyy");
    SimpleDateFormat formatter2=new SimpleDateFormat("dd-MMM-yyyy");
    SimpleDateFormat formatter3=new SimpleDateFormat("MM dd, yyyy");
    SimpleDateFormat formatter4=new SimpleDateFormat("E, MMM dd yyyy");
    SimpleDateFormat formatter5=new SimpleDateFormat("E, MMM dd yyyy HH:mm:ss");
    SimpleDateFormat formatter6=new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss");
    Date date1=formatter1.parse(sDate1);
    Date date2=formatter2.parse(sDate2);
    Date date3=formatter3.parse(sDate3);
    Date date4=formatter4.parse(sDate4);
    Date date5=formatter5.parse(sDate5);
    Date date6=formatter6.parse(sDate6);
	System.out.println(sDate1+"\t"+date1);
	System.out.println(sDate2+"\t"+date2);
	System.out.println(sDate3+"\t"+date3);
	System.out.println(sDate4+"\t"+date4);
	System.out.println(sDate5+"\t"+date5);
	System.out.println(sDate6+"\t"+date6);
}
}

Output:

31/12/1998	Thu Dec 31 00:00:00 IST 1998
31-Dec-1998	Thu Dec 31 00:00:00 IST 1998
12 31, 1998	Thu Dec 31 00:00:00 IST 1998
Thu, Dec 31 1998	Thu Dec 31 00:00:00 IST 1998
Thu, Dec 31 1998 23:37:50	Thu Dec 31 23:37:50 IST 1998
31-Dec-1998 23:37:50	Thu Dec 31 23:37:50 IST 1998

Using Instant Class

In Java, the java.time package contains the Instant class which provides the users with an accuracy in nanoseconds. The accuracy provided by the Instant class is better when compared with that of Date class.

The approach or algorithm of this method is very simple. The string that needs to be converted must be taken as input from user or assigned value. Then an empty object of Instant timestamp must be created. Upon successful creation of the timestamp object, the string will be converted to Date with the help of Instant.parse() method of Java. Upon unsuccessful creation, a DateTimeParseException will be thrown.

Let's understand about this approach in detail with the help of an example Java program.

Filename: StringToDate.java

import java.time.Instant;
import java.time.format.DateTimeParseException;
public class StringToDate {
	// Method utilized for the conversion of String variable to Date format.
	public static Instant fetchDate(String s) {
		// Creation of an Instant object
		Instant TimeStamp = null;
		// Parsing through the string to Date
		TimeStamp = Instant.parse(s);
		// Returning the converted TimeStamp with Date format.
		return TimeStamp;
	}
	public static void main(String[] args) {
		// Input the string value
		String s = "2020-03-28T10:15:01Z";
		// Trying to block for checking for runtime exceptions
		try {
			// Fetching the Date from String by
			// Creation of an object of the Instant class
			Instant TimeStamp = fetchDate(s);
			// Displaying the successfully converted date
			System.out.println("Date Converted From String: " + TimeStamp);
		} catch (DateTimeParseException e) {
			// Throws DateTimeParseException
			// Only if the string cannot be parsed
			System.out.println("Exception occurred while parsing: " + e.getMessage());
		} catch (Exception e) {
			// Handles any other runtime exceptions
			System.out.println("An unexpected error occurred: " + e.getMessage());
		}
	}
}

Output:

Date Converted From String: 2020-03-28T10:15:01Z

It was the procedure or method for the conversion of a String value to a Date format. Let us look at another methods or approaches for converting String to Date.

Using DateTimeFormatter Class

In this approach or technique, the DateTimeFormatter class will be utilized for the conversion of a String into a Date format. The approach or algorithm for this method is mentioned below.

Fetch the string that needs to be converted into a date either by user or assign the value manually. An empty LocalDate object must be created. The String must then be converted into date format utilizing the LocalDate.parse() method. Upon successful conversion, display the resultant date. An IllegalArgumentException might be thrown if the input string is not valid.

Let's understand about this approach in detail with the help of a Java example program.

Filename: StringToDate1.java

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
public class StringToDate1 {
	public static LocalDate fetchDateFromString(String s, DateTimeFormatter format) {
		LocalDate d = LocalDate.parse(s, format);
		// Returning the converted d at the end
		return d;
	}
	public static void main(String[] args) {
		String s = "26 September, 2002";
		// Getting the format by creating an object of DateTImeFormatter class
		DateTimeFormatter format = DateTimeFormatter.ofPattern("d MMMM, yyyy");
		// Try block to check for exceptions
		try {
			// Getting the Date from String
			LocalDate d = fetchDateFromString(s, format);
			// Printing the converted d
			System.out.println(d);
		}
		// Block 1
		// Catch block to handle exceptions occurring
		// if the String pattern is invalid
		catch (IllegalArgumentException e) {
			// Display the exception
			System.out.println("Exception: " + e);
		}
		// Block 2
		// If the String was unable to be parsed
		catch (DateTimeParseException e) {
			// Display the exception
			System.out.println("Exception: " + e);
		}
	}
}

Output:

2002-09-26

Using SimpleDateFormat Class

In this approach or technique, the SimpleDateFormat class will be utilized for the conversion of a string into a date format. Let's understand in detail about the algorithm or approach.

The input string must be declared and assigned with value. An object of the Date class must be created which refers to the SimpleDateFormat class. Then the date format must be parsed into it. Then the final result must be displayed . Let's understand about this approach in detail with the help of a Java example program.

Filename: StringToDate2.java

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
public class StringToDate2 {
	// Method utilized for generating a random date string
	public static String generateRandomDateString() {
		Random random = new Random();
		int d = random.nextInt(28) + 1; // Random d between 1 and 28
		int m = random.nextInt(12) + 1; // Random m between 1 and 12
		int y = random.nextInt(100) + 1900; // Random y between 1900 and 1999
		return String.format("%02d/%02d/%04d", d, m, y); // Format the date string
	}
	// Method utilized for calculating age based on parsed date
	public static int calculateAge(Date birthDate) {
		Date cd = new Date();
		long dIMillis = Math.abs(cd.getTime() - birthDate.getTime());
		long Diff = dIMillis / (24 * 60 * 60 * 1000 * 365L);
		return (int) Diff;
	}
	public static void main(String[] args) {
		try {
			for (int i = 0; i < 5; i++) { // Generate and process 5 random dates
				// Generate a random date string
				String randomDateStr = generateRandomDateString();
				// Print the generated random date string
				System.out.println("Random Date String: " + randomDateStr);
				// Creating an object of Date class with reference
				// to SimpleDateFormat class and
				// parsing the above string into it
				Date date = new SimpleDateFormat("dd/MM/yyyy").parse(randomDateStr);
				// Print and display the date corresponding
				// to the generated random date string
				System.out.println("Parsed Date: " + date);
				// Calculate and print age based on parsed date
				int age = calculateAge(date);
				System.out.println("Age: " + age + " years\n");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Output:

Random Date String: 15/09/1996
Parsed Date: Sun Sep 15 00:00:00 IST 1996
Age: 27 years

Random Date String: 01/11/1950
Parsed Date: Wed Nov 01 00:00:00 IST 1950
Age: 73 years

Random Date String: 20/11/1955
Parsed Date: Sun Nov 20 00:00:00 IST 1955
Age: 68 years

Random Date String: 09/07/1927
Parsed Date: Sat Jul 09 00:00:00 IST 1927
Age: 96 years

Random Date String: 27/08/1913
Parsed Date: Wed Aug 27 00:00:00 IST 1913
Age: 110 years

Next TopicJava Date to String

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.