LocalDateTime yourDate = ... ... // Adds 1 hour to your date. yourDate = yourDate. plus(Duration. parse("PT1H")); // Java. // OR yourDate = yourDate + Duration.
DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss"); Date currentDate = new Date(); final long reqHoursInMillis = 1 * 60 * 60 * 1000; // change 1 with required hour Date newDate = new Date(currentDate. getTime() + reqHoursInMillis); System. out. println(dateFormat.
To add hours to time in Java, you can use plusHours() method of the LocalDateTime class in Java.
getTime. Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT represented by this Date object.
Check Calendar
class. It has add
method (and some others) to allow time manipulation.
Something like this should work:
Calendar cal = Calendar.getInstance(); // creates calendar
cal.setTime(new Date()); // sets calendar time/date
cal.add(Calendar.HOUR_OF_DAY, 1); // adds one hour
cal.getTime(); // returns new date object plus one hour
Check API for more.
If you use Apache Commons / Lang, you can do it in one step using DateUtils.addHours()
:
Date newDate = DateUtils.addHours(oldDate, 3);
(The original object is unchanged)
To simplify @Christopher's example.
Say you have a constant
public static final long HOUR = 3600*1000; // in milli-seconds.
You can write.
Date newDate = new Date(oldDate.getTime() + 2 * HOUR);
If you use long to store date/time instead of the Date object you can do
long newDate = oldDate + 2 * HOUR;
myJavaUtilDate.toInstant()
.plusHours( 8 )
Or…
myJavaUtilDate.toInstant() // Convert from legacy class to modern class, an `Instant`, a point on the timeline in UTC with resolution of nanoseconds.
.plus( // Do the math, adding a span of time to our moment, our `Instant`.
Duration.ofHours( 8 ) // Specify a span of time unattached to the timeline.
) // Returns another `Instant`. Using immutable objects creates a new instance while leaving the original intact.
The java.time framework built into Java 8 and later supplants the old Java.util.Date/.Calendar classes. Those old classes are notoriously troublesome. Avoid them.
Use the toInstant
method newly added to java.util.Date to convert from the old type to the new java.time type. An Instant
is a moment on the time line in UTC with a resolution of nanoseconds.
Instant instant = myUtilDate.toInstant();
You can add hours to that Instant
by passing a TemporalAmount
such as Duration
.
Duration duration = Duration.ofHours( 8 );
Instant instantHourLater = instant.plus( duration );
To read that date-time, generate a String in standard ISO 8601 format by calling toString
.
String output = instantHourLater.toString();
You may want to see that moment through the lens of some region’s wall-clock time. Adjust the Instant
into your desired/expected time zone by creating a ZonedDateTime
.
ZoneId zoneId = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = ZonedDateTime.ofInstant( instant , zoneId );
Alternatively, you can call plusHours
to add your count of hours. Being zoned means Daylight Saving Time (DST) and other anomalies will be handled on your behalf.
ZonedDateTime later = zdt.plusHours( 8 );
You should avoid using the old date-time classes including java.util.Date
and .Calendar
. But if you truly need a java.util.Date
for interoperability with classes not yet updated for java.time types, convert from ZonedDateTime
via Instant
. New methods added to the old classes facilitate conversion to/from java.time types.
java.util.Date date = java.util.Date.from( later.toInstant() );
For more discussion on converting, see my Answer to the Question, Convert java.util.Date to what “java.time” type?.
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
.
The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.
To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.
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.
Where to obtain the java.time classes?
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.
With Joda-Time
DateTime dt = new DateTime();
DateTime added = dt.plusHours(6);
Since Java 8:
LocalDateTime.now().minusHours(1);
See LocalDateTime
API.
Using the newish java.util.concurrent.TimeUnit class you can do it like this
Date oldDate = new Date(); // oldDate == current time
Date newDate = new Date(oldDate.getTime() + TimeUnit.HOURS.toMillis(2)); // Add 2 hours
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With