How to convert java.util.Date to java.sql.Date?

java sql datetime date

702,331

Solution 1

tl;dr

How to convert java.util.Date to java.sql.Date?

Don’t.

Both Date classes are outmoded. Sun, Oracle, and the JCP community gave up on those legacy date-time classes years ago with the unanimous adoption of JSR 310 defining the java.time classes.

Use java.time classes instead of legacy java.util.Date & java.sql.Date with JDBC 4.2 or later.
Convert to/from java.time if inter-operating with code not yet updated to java.time.

Legacy	Modern	Conversion
`java.util.Date`	`java.time.Instant`	`java.util.Date.toInstant()` `java.util.Date.from( Instant )`
`java.sql.Date`	`java.time.Date`	`java.sql.Date.toLocalDate()` `java.sql.Date.valueOf( LocalDate )`

Example query with PreparedStatement.

myPreparedStatement.setObject( 
    … ,                                         // Specify the ordinal number of which argument in SQL statement.
    myJavaUtilDate.toInstant()                  // Convert from legacy class `java.util.Date` (a moment in UTC) to a modern `java.time.Instant` (a moment in UTC).
        .atZone( ZoneId.of( "Africa/Tunis" ) )  // Adjust from UTC to a particular time zone, to determine a date. Instantiating a `ZonedDateTime`.
        .toLocalDate()                          // Extract a date-only `java.time.LocalDate` object from the date-time `ZonedDateTime` object.
)

Replacements:

Instant instead of java.util.Date
Both represent a moment in UTC. but now with nanoseconds instead of milliseconds.
LocalDate instead of java.sql.Date
Both represent a date-only value without a time of day and without a time zone.

Details

If you are trying to work with date-only values (no time-of-day, no time zone), use the LocalDate class rather than java.util.Date.

java.time

In Java 8 and later, the troublesome old date-time classes bundled with early versions of Java have been supplanted by the new java.time package. See Oracle Tutorial. Much of the functionality has been back-ported to Java 6 & 7 in ThreeTen-Backport and further adapted to Android in ThreeTenABP.

A SQL data type DATE is meant to be date-only, with no time-of-day and no time zone. Java never had precisely such a class† until java.time.LocalDate in Java 8. Let's create such a value by getting today's date according to a particular time zone (time zone is important in determining a date as a new day dawns earlier in Paris than in Montréal, for example).

LocalDate todayLocalDate = LocalDate.now( ZoneId.of( "America/Montreal" ) );  // Use proper "continent/region" time zone names; never use 3-4 letter codes like "EST" or "IST".

At this point, we may be done. If your JDBC driver complies with JDBC 4.2 spec, you should be able to pass a LocalDate via setObject on a PreparedStatement to store into a SQL DATE field.

myPreparedStatement.setObject( 1 , localDate );

Likewise, use ResultSet::getObject to fetch from a SQL DATE column to a Java LocalDate object. Specifying the class in the second argument makes your code type-safe.

LocalDate localDate = ResultSet.getObject( 1 , LocalDate.class );

In other words, this entire Question is irrelevant under JDBC 4.2 or later.

If your JDBC driver does not perform in this manner, you need to fall back to converting to the java.sql types.

Convert to java.sql.Date

To convert, use new methods added to the old date-time classes. We can call java.sql.Date.valueOf(…) to convert a LocalDate.

java.sql.Date sqlDate = java.sql.Date.valueOf( todayLocalDate );

And going the other direction.

LocalDate localDate = sqlDate.toLocalDate();

Converting from `java.util.Date`

While you should avoid using the old date-time classes, you may be forced to when working with existing code. If so, you can convert to/from java.time.

Go through the Instant class, which represents a moment on the timeline in UTC. An Instant is similar in idea to a java.util.Date. But note that Instant has a resolution up to nanoseconds while java.util.Date has only milliseconds resolution.

To convert, use new methods added to the old classes. For example, java.util.Date.from( Instant ) and java.util.Date::toInstant.

Instant instant = myUtilDate.toInstant();

To determine a date, we need the context of a time zone. For any given moment, the date varies around the globe by time zone. Apply a ZoneId to get a ZonedDateTime.

ZoneId zoneId = ZoneId.of ( "America/Montreal" );
ZonedDateTime zdt = ZonedDateTime.ofInstant ( instant , zoneId );
LocalDate localDate = zdt.toLocalDate();

† The java.sql.Date class pretends to be date-only without a time-of-day but actually does a time-of-day, adjusted to a midnight time. Confusing? Yes, the old date-time classes are a mess.

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.

To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes. Hibernate 5 & JPA 2.2 support java.time.

Where to obtain the java.time classes?

Java SE 8, Java SE 9, Java SE 10, Java SE 11, and later - Part of the standard Java API with a bundled implementation.
- Java 9 brought some minor features and fixes.
Java SE 6 and Java SE 7
- Most of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
Android
- Later versions of Android (26+) bundle implementations of the java.time classes.
- For earlier Android (<26), a process known as API desugaring brings a subset of the java.time functionality not originally built into Android.
  - If the desugaring does not offer what you need, the ThreeTenABP project adapts ThreeTen-Backport (mentioned above) to Android. See How to use ThreeTenABP….

The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval, YearWeek, YearQuarter, and more.

Solution 2

Nevermind....

public class MainClass {

  public static void main(String[] args) {
    java.util.Date utilDate = new java.util.Date();
    java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
    System.out.println("utilDate:" + utilDate);
    System.out.println("sqlDate:" + sqlDate);

  }

}

explains it. The link is http://www.java2s.com/Tutorial/Java/0040__Data-Type/ConvertfromajavautilDateObjecttoajavasqlDateObject.htm

Solution 3

With the other answer you may have troubles with the time info (compare the dates with unexpected results!)

I suggest:

java.util.Calendar cal = Calendar.getInstance();
java.util.Date utilDate = new java.util.Date(); // your util date
cal.setTime(utilDate);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);    
java.sql.Date sqlDate = new java.sql.Date(cal.getTime().getTime()); // your sql date
System.out.println("utilDate:" + utilDate);
System.out.println("sqlDate:" + sqlDate);

Solution 4

This function will return a converted SQL date from java date object.

public java.sql.Date convertJavaDateToSqlDate(java.util.Date date) {
    return new java.sql.Date(date.getTime());
}

Solution 5

Converting java.util.Date to java.sql.Date will lose hours, minutes and seconds. So if it is possible, I suggest you to use java.sql.Timestamp like this:

prepareStatement.setTimestamp(1, new Timestamp(utilDate.getTime()));

For more info, you can check this question.

View more solutions

702,331

Author by

David Ackerman

Updated on August 05, 2021

Comments

David Ackerman almost 3 years

I am trying to use a java.util.Date as input and then creating a query with it - so I need a java.sql.Date.

I was surprised to find that it couldn't do the conversion implicitly or explicitly - but I don't even know how I would do this, as the Java API is still fairly new to me.
darioo over 13 years

If he's using java.sql.Date for a Date column in a database, that time information will be truncated. You've overengineered the solution in my opinion.
mauretto over 13 years

Yes, maybe I did it. I sometimes need to compare the java.sql.Data with the current date and imho this is the best way. I hope it can help.
Admin about 12 years

This is not an explicit conversion! From the Javadoc: "If the given milliseconds value contains time information, the driver will set the time components to the time in the default time zone (the time zone of the Java virtual machine running the application) that corresponds to zero GMT." So no matter what your time on your java.util.Date, it will be inserted as 00:00:00 in a column with the data type set to DATE.
jontro about 12 years

Welcome to stackoverflow, I have a few comments to your answer. The question was "how to convert a java.util.Date to java.sql.Date". The code you pasted formats a java.util.Date as yyyy-MM-dd. This is actually of limited use in this context since you should pass the java.sql.Date directly to the jdbc drivers instead of doing it as a string.
Arjun K P about 12 years

@David Ackerman.....this method returns the epochseconds i.e milliseconds after 1,JAN,1970. But What if we want to store the date of a person before this date....or something like 0000-00-00 as default
Alberto de Paola almost 12 years

In my case the correct answer is <code>java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(utilDate.getTime());</code>, because it preserves the time fields.
Amir Pashazadeh about 11 years

@ArjunKP A java long can be assigned negative numbers, and that's negative numbers for in a Date.
wired00 over 9 years

It begs the question, why there are two different Date objects which are incompatible as part of java's design? Shouldn't it be named SQLDate or something instead of Date?
Basil Bourque almost 9 years

@wired00 Yes, the old date-time classes bundled with the early versions of Java are a mess, badly designed including some crude hacks. Whenever possible, try to use the new java.time framework in Java 8 and later. These new classes supplant the old. The java.time classes and the old classes have some convenience methods for converting back and forth -- useful while we wait for JDBC drivers to be updated to directly utilize the new java.time types.
wired00 almost 9 years

@BasilBourque thanks very much on java.time will check into it
Basil Bourque almost 9 years

@wired00 See my new Answer on this Question for how to use java.time. Also search StackOverflow for many more examples.
Bernhard Barker over 6 years

There's no DateUtilities class in the standard Java library (and I can't even find this method anywhere at all from a quick Google search). If this is from a specific library, you might want to say as much and include a link to the docs.
Bernhard Barker over 6 years

This appears to be essentially the same as this answer posted a year earlier.
Basil Bourque over 5 years

FYI, the terribly troublesome old date-time classes such as java.util.Date, java.util.Calendar, and java.text.SimpleDateFormat are now legacy, supplanted by the java.time classes built into Java 8 and later. See Tutorial by Oracle.
Basil Bourque over 5 years

FYI, the terribly troublesome old date-time classes such as java.util.Date, java.util.Calendar, and java.text.SimpleDateFormat are now legacy, supplanted by the java.time classes built into Java 8 and later. See Tutorial by Oracle.
mauretto over 5 years

Of course, this topic was about 10 yrs ago, pre-java 8.
sf_jeff almost 4 years

"While you should avoid using the old date-time classes, you may be forced to when working with existing code. If so, you can convert to/from java.time." Actually, no. This and the the Date.valueOf() are actually not available in the JDBC/Java7 paradigm.
Basil Bourque almost 4 years

@sf_jeff Java 7 support is covered in the bullets at the end of my Answer: Where to obtain the java.time classes?
Basil Bourque almost 4 years

@Brain Reread Convert to … & Converting from… sections. To interoperate with old code not yet updated to java.time, do your business logic in java.time. At the edges convert between modern & legacy types by calling new methods added to the old classes. For java.sql.Date, see the toLocalDate and valueOf( LocalDate ) methods. Never write new code using the old classes.
dnebing almost 3 years

I downvoted this answer, but not because it is incorrect. The OP asked how to do it, not for a browbeating over the use of legacy date objects or whether there was a better / newer way. For all Basil knows, the OP was constrained to an older version of java or a library that only allowed for those two types, yada yada yada.
Basil Bourque almost 3 years

@dnebing No browbeating intended. You may not realize just how terribly bad are the legacy date-time classes. Sun, Oracle, & the JCP community all gave up on these classes years ago with unanimous adoption of JSR 310. The java.time classes come bundled with Java 8 and later. All the legacy classes carry new methods for converting back-and-forth between legacy and modern objects. A back-port is available for Java 6 & 7, parallel API. That back-port is equipped with conversion methods as well. So there really is no reason to not be using java.time.
dnebing almost 3 years

I know how bad they are. The OP probably knows how bad they are. The question wasn't about how bad they are, though, the question was just how to do it, and the answer should have stuck to that, IMHO. Don't get me wrong, your answer is absolutely right for the question "Should I still use java.util.Date or not?", so kudos for that.