Develop Reference

How to calculate how much hours have to 00.00 in android with Java

I'll create a count timer for my android app. I want to calculate how much time have in 24:00 in hours from current time. I couldn't not find any solutions and it's so complicated for me to calculate it with miliseconds.
For Example:
Now time is: 22.55
Have 1 hours and 5 minutes to 00.00
I'll make count timer with this like:
Remaining: 1 hours 5 Minutes
Anyone can help me?
Thanks a lot.

You can use java.time.Duration to compute the time difference between now and midnight:
LocalDateTime now = LocalDateTime.now();
LocalDateTime midnight = LocalDate.now().plusDays(1).atTime(0, 0);
Duration between = Duration.between(now, midnight);
System.out.printf("Remaining: %d hours %d minutes",
between.toHours(), between.toMinutes() % 60);

Days are not always 24 hours long
On some dates in some time zones, the day is not 24 hours long. Some days may run 23, 23.5, 25, or some other number of hours long.
So let java.time determine the first moment of the following day.
ZoneId z = ZoneId.of( "Asia/Tokyo" ) ; // Or ZoneId.systemDefault() ;
ZonedDateTime zdt = ZonedDateTime.now( z ).with( LocalTime.of( 22 , 55 ) ) ;
ZonedDateTime firstMomentOfTomorrow = zdt.toLocalDate().plusDays( 1 ).atStartOfDay( z ) ;
Duration d = Duration.between( zdt , firstMomentOfTomorrow ) ;
System.out.println(
zdt.toString() + "/" + firstMomentOfTomorrow.toString() + " = " + d.toString()
);
See this code run live at IdeOne.com.
2021-12-28T22:55+09:00[Asia/Tokyo]/2021-12-29T00:00+09:00[Asia/Tokyo] = PT1H5M

Java API to get the start and end detail of Daylight saving time for a particular timezone for a year

So I am using getAvailableZoneIds() method under java.time.ZoneId to fetch a list of available timezones.
I wanted to know if there is a way by which for a specific timezone eg- “America/Chicago” , I can find out the starting and ending date time detail of daylight saving time for a year.
Like when does it start and ends.
Gone though various classes including ZoneId ,ZonedDateTime, ZoneOffset,TimeZone available in java but not able to find any way by which I can fetch this details.
I tried the below code and gives output mentioned below
ZoneId zoneId= ZoneId.of("America/Sao_Paulo");
ZoneRules zoneRules = zoneId.getRules();
System.out.println("previous Transition of DST ==> " + zoneRules.previousTransition(Instant.now()));
System.out.println("next Transition of DST ==> " + zoneRules.nextTransition(Instant.now()));
Output:
previous Transition of DST ==> Transition[Overlap at 2019-02-17T00:00-02:00 to -03:00]
next Transition of DST ==> Transition[Gap at 2019-11-03T00:00-03:00 to -02:00]
But I need to find out for a particular year , what time it starts and what time does it end .

For a particular year, you can give ZoneRules a year as part of specifying a moment. For any given moment, you can ask next or previous ZoneOffsetTransition.
Here is example code for Europe/Sofia time zone.
ZoneId zoneSofia = ZoneId.of( "Europe/Sofia" );
ZoneRules zoneRules = zoneSofia.getRules();
// Pick a moment, arbitrarily.
ZonedDateTime zdt = ZonedDateTime.of( 2019 , 10 , 15 , 10 , 0 , 0 , 0 , zoneSofia );
// Is DST in effect at that moment?
boolean isDst = zoneRules.isDaylightSavings( zdt.toInstant() );
// When are the closest offset transitions, previous (in the past), and next (in the future).
ZoneOffsetTransition previousTransition = zoneRules.previousTransition( zdt.toInstant() );
ZoneOffsetTransition nextTransition = zoneRules.nextTransition( zdt.toInstant() );
// When is the next transition happening in UTC? In Sofia time?
Instant nextTransitionInstant = nextTransition.getInstant(); // An `Instant`` is always in UTC, by definition.
ZonedDateTime nextTransactionZdt = nextTransitionInstant.atZone( zoneSofia ); // Same moment, same point on the timeline, different wall-clock time.
boolean isDstAfterTransition = zoneRules.isDaylightSavings( nextTransactionZdt.toInstant() );
Dump to console.
System.out.println( "zone = " + zoneSofia );
System.out.println( "zdt: " + zdt );
System.out.println( "isDst: " + isDst );
System.out.println( "previousTransition = " + previousTransition );
System.out.println( "nextTransition = " + nextTransition );
System.out.println( "nextTransitionInstant = " + nextTransitionInstant );
System.out.println( "nextTransactionZdt = " + nextTransactionZdt );
System.out.println( "isDstAfterTransition = " + isDstAfterTransition );
zone = Europe/Sofia
zdt: 2019-10-15T10:00+03:00[Europe/Sofia]
isDst: true
previousTransition = Transition[Gap at 2019-03-31T03:00+02:00 to +03:00]
nextTransition = Transition[Overlap at 2019-10-27T04:00+03:00 to +02:00]
nextTransitionInstant = 2019-10-27T01:00:00Z
nextTransactionZdt = 2019-10-27T03:00+02:00[Europe/Sofia]
isDstAfterTransition = false
We can see than the next transition in Europe/Sofia happens at the moment that would look like 4 AM while 3 hours ahead of UTC:
nextTransition = Transition[Overlap at 2019-10-27T04:00+03:00 to +02:00]
…but since we are doing a Daylight Saving Time (DST) “Fall back”, we turn the hands of the clock back to 3 AM to be 2 hours ahead of UTC:
nextTransactionZdt = 2019-10-27T03:00+02:00[Europe/Sofia]
And we can see with isDstAfterTransition that at that moment we are no longer in DST.
Notice how, on this date of the 27th, the people of the the Sofia region experience the hour of 3-4 AM twice. This first 3-4 AM hour is at 3 hours ahead of UTC. The second 3-4 AM hour is at 2 hours ahead of UTC.
And, this means the day of the 27th runs 25 hours long rather than 24.

How to convert Date based on String value for TimeZone

I have a Date Object which I need to convert to the logged in user's timezone. The problem is that the timezone is represented in our DB simply as a String value of GMT plus or minus the offset in hours. So for example "GMT" or "GMT-5" for New york time or "GMT+5".
How can I convert my Date Object to the User's time when all I have are String like "GMT-3" or "GMT+5"?
Thanks in advance for any help.

An example should help, but it seems a 1 character ISO 8601 time zone:
String myDate="2001-07-04T12:08:56GMT-3";
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'GMT'X");
if (myDate.indexOf("GMT-") >= myDate.length() -1 -4) {
myDate = myDate.replace("-","-0");
}
if (myDate.indexOf("GMT+") >= myDate.length() -1 -4) {
myDate = myDate.replace("+","+0");
}
System.out.println(format.parse(myDate));
it should work.
the yyyy-MM-dd'T'HH:mm:ss'GMT'X is compliant with iso8601 time zone
myDate = myDate.replace("-","-0"); adjusts the date to your format

Offset ≠ Time Zone
As Jon Skeet said in comment, a time zone is more than just an offset from UTC/GMT. Storing the offset hours (and minutes) is a less-than-optimal strategy for handling date-time in your database/storage.
Joda-Time
The java.util.Date & java.util.Calendar classes are notoriously troublesome. Avoid them. Use Joda-Time. Or, in Java 8, use the new java.time.* package, defined by JSR 310, and inspired by Joda-Time but re-architected.
We can create a DateTimeZone to represent the offset, but as noted this does not make a complete time zone logically.
We can pass a java.util.Date object directly to a Joda-Time DateTime constructor. Along with that we pass a DateTimeZone object. To go the other direction of conversion, call toDate on a DateTime object.
java.util.Date date = new java.util.Date(); // Retrieved from elsewhere. Faked here.
String offsetInput = "GMT-5";
int offsetHours = 0, offsetMinutes = 0;
offsetInput = offsetInput.replace( "GMT", "" ); // Delete 'GMT' characters.
String[] parts = offsetInput.split(":"); // About splitting a string: http://stackoverflow.com/q/3481828/642706
// Handle results of split.
if( parts.length == 0 ) {
// Add some error handling here
}
if ( parts.length >= 1 ) {
offsetHours = Integer.parseInt( parts[0] ); // Retrieve text of first number (zero-based index counting).
}
if ( parts.length >= 2 ) {
offsetMinutes = Integer.parseInt( parts[1] ); // Retrieve text of second number (zero-based index counting).
}
if( parts.length >= 3 ) {
// Add some error handling here
}
DateTimeZone partialTimeZoneWithOnlyOffset = DateTimeZone.forOffsetHoursMinutes( offsetHours, offsetMinutes );
DateTime dateTime = new DateTime( date, partialTimeZoneWithOnlyOffset );
Dump to console…
System.out.println( "date: " + date ); // BEWARE: JVM's default time zone applied in the implicit call to "toString" of a Date. Very misleading.
System.out.println( "partialTimeZoneWithOnlyOffset: " + partialTimeZoneWithOnlyOffset );
System.out.println( "dateTime: " + dateTime );
System.out.println( "dateTime with alternate formatting: " + DateTimeFormat.forStyle( "FF" ).withLocale( Locale.US ).print( dateTime ) );
When run…
date: Sat Feb 08 22:40:57 PST 2014
partialTimeZoneWithOnlyOffset: -05:00
dateTime: 2014-02-09T01:40:57.810-05:00
dateTime with alternate formatting: Sunday, February 9, 2014 1:40:57 AM -05:00

How to add days to date fetched from database with hibernate

i am fetching date from Oracle database using rp.getStart_date() with hibernate
now i want to add 15 days to it and display it. but as cal.add() requires first argument as int,it is showing me numberFormatException on second line..how do i do it?
Date dt=rp.getStart_date();
int s1=Integer.parseInt((dt.toString()));
System.out.println(s1);
SimpleDateFormat sdf=new SimpleDateFormat("dd-MM-yyyy");
Calendar cal=Calendar.getInstance();
cal.add(s1, 15);
System.out.println(sdf.format(cal.getTime()));
please help me out..
Thanks in advance..

Try,
Date dt = rp.getStart_date();
SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
Calendar cal = Calendar.getInstance();
cal.setTime(dt);
cal.add(Calendar.DATE, 15); // Add 15 days
String output = sdf.format(cal.getTime());
System.out.println("Output :: "+output);

Neglected Time Zone
The answer by Rakesh KR is close but not quite right. Both the question and that answer fail to think about time zone. If you neglect to specify a time zone, you get the JVM's default time zone. By relying on default time zone, you may have unexpected results.
DST Effect
The add method of java.util.Calendar retains the hour-of-day, adjusting for Daylight Saving Time (DST) and possibly other anomalies. So if you use a time zone (like United States west coast) that changes Daylight Saving Time by an hour during your time span, you actually will have one extra/less hour. That is, your result in hours of adding 15 days is ( ( 15 * 24 ) ± 1 ).
If you were expecting ( 15 * 24 ) consistently, you will be surprised (depending default time zone of JVM).
Demonstration
Since the plusDays method on DateTime class in Joda-Time has the same behavior, I'll demonstrate using Joda-Time. You should be avoiding java.util.Date & java.util.Calendar anyways, but in this scenario the behavior is the same as Joda-Time.
First, for your information, the code from the other answer could be done Joda-Time like this, converting to-and-fro between the java.util.Date world and Joda-Time world. But this code has the same time zone issue (affected by DST).
java.util.Date juDate = new java.util.Date();
java.util.Date juDateLater = new DateTime( juDate ).plusDays( 15 ).toDate() ;
Now using pure Joda-Time let's look at how time zone affects the addition of days. We will run this example code twice, first as-is, then swapping time zones by commenting out the first timeZone line and enabling the line after that.
// Time zone "America/Los_Angeles" begins DST on 2014-03-09 02:00, springing ahead to 03:00.
DateTimeZone timeZone = DateTimeZone.forID( "America/Los_Angeles" );
//DateTimeZone timeZone = DateTimeZone.UTC;
DateTime dateTime_OneAM = new DateTime( 2014, 3, 9, 1, 0, 0, timeZone );
DateTime dateTime_OneAM_Plus15 = dateTime_OneAM.plusDays( 15 );
DateTime dateTime_ThreeAM = new DateTime( 2014, 3, 9, 3, 0, 0, timeZone );
DateTime dateTime_ThreeAM_Plus15 = dateTime_ThreeAM.plusDays( 15 );
long millisElapsedOneAM = ( dateTime_OneAM_Plus15.getMillis() - dateTime_OneAM.getMillis() );
long millisElapsedThreeAM = ( dateTime_ThreeAM_Plus15.getMillis() - dateTime_ThreeAM.getMillis() );
long minutes = ( ( millisElapsedThreeAM - millisElapsedOneAM ) / 1000L / 60L );
Dump to console…
System.out.println( "timeZone " + timeZone );
System.out.println( "dateTime_OneAM " + dateTime_OneAM + " ( UTC/GMT: " + dateTime_OneAM.toDateTime( DateTimeZone.UTC ) + " )" );
System.out.println( "dateTime_OneAM_Plus15 " + dateTime_OneAM_Plus15 + " ( UTC/GMT: " + dateTime_OneAM_Plus15.toDateTime( DateTimeZone.UTC ) + " )" );
System.out.println( " " ); // Blank line.
System.out.println( "dateTime_ThreeAM " + dateTime_ThreeAM + " ( UTC/GMT: " + dateTime_ThreeAM.toDateTime( DateTimeZone.UTC ) + " )" );
System.out.println( "dateTime_ThreeAM_Plus15 " + dateTime_ThreeAM_Plus15 + " ( UTC/GMT: " + dateTime_ThreeAM_Plus15.toDateTime( DateTimeZone.UTC ) + " )" );
System.out.println( " " ); // Blank line.
System.out.println( "millisElapsedOneAM " + millisElapsedOneAM );
System.out.println( "millisElapsedThreeAM " + millisElapsedThreeAM );
System.out.println( "minutes " + minutes );
When run using the first time zone, for US west coast…(Note how hour-of-day in UTC changing or not changing)
timeZone America/Los_Angeles
dateTime_OneAM 2014-03-09T01:00:00.000-08:00 ( UTC/GMT: 2014-03-09T09:00:00.000Z )
dateTime_OneAM_Plus15 2014-03-24T01:00:00.000-07:00 ( UTC/GMT: 2014-03-24T08:00:00.000Z )
dateTime_ThreeAM 2014-03-09T03:00:00.000-07:00 ( UTC/GMT: 2014-03-09T10:00:00.000Z )
dateTime_ThreeAM_Plus15 2014-03-24T03:00:00.000-07:00 ( UTC/GMT: 2014-03-24T10:00:00.000Z )
millisElapsedOneAM 1292400000
millisElapsedThreeAM 1296000000
minutes 60
When run using the second time zone, for UTC/GMT…
timeZone UTC
dateTime_OneAM 2014-03-09T01:00:00.000Z ( UTC/GMT: 2014-03-09T01:00:00.000Z )
dateTime_OneAM_Plus15 2014-03-24T01:00:00.000Z ( UTC/GMT: 2014-03-24T01:00:00.000Z )
dateTime_ThreeAM 2014-03-09T03:00:00.000Z ( UTC/GMT: 2014-03-09T03:00:00.000Z )
dateTime_ThreeAM_Plus15 2014-03-24T03:00:00.000Z ( UTC/GMT: 2014-03-24T03:00:00.000Z )
millisElapsedOneAM 1296000000
millisElapsedThreeAM 1296000000
minutes 0

Java: calculating duration

I created the following code to calculate the duration between two timestamps which can come in two different formats:
public class dummyTime {
public static void main(String[] args) {
try {
convertDuration("2008-01-01 01:00 pm - 01:56 pm");
convertDuration("2008-01-01 8:30 pm - 2008-01-02 09:30 am");
} catch (Exception e) {
e.printStackTrace();
}
}
private static String convertDuration(String time) throws Exception {
String ts[] = time.split(" - ");
SimpleDateFormat formatNew = new SimpleDateFormat("HH:mm");
Date beg, end;
String duration = null;
beg = getDateTime(ts[0]);
end = getDateTime(ts[1], beg);
duration = formatNew.format(end.getTime() - beg.getTime());
System.out.println(duration + " /// " + time + " /// " + beg + " /// "
+ end);
return duration;
}
private static Date getDateTime(String dateTime) throws ParseException {
DateFormat formatOldDateTime = new SimpleDateFormat(
"yyyy-MM-dd hh:mm aa");
DateFormat formatOldTimeOnly = new SimpleDateFormat("hh:mm aa");
Date date = null;
try {
date = formatOldDateTime.parse(dateTime);
} catch (ParseException e) {
date = formatOldTimeOnly.parse(dateTime);
}
return date;
}
private static Date getDateTime(String dateTime, Date orig)
throws ParseException {
Date end = getDateTime(dateTime);
if (end.getYear() == 70) {
end.setYear(orig.getYear());
end.setMonth(orig.getMonth());
end.setDate(orig.getDate());
}
return end;
}
}
The output it generates is:
01:56 /// 2008-01-01 01:00 pm - 01:56 pm /// Tue Jan 01 13:00:00 CET 2008 /// Tue Jan 01 13:56:00 CET 2008
14:00 /// 2008-01-01 8:30 pm - 2008-01-02 09:30 am /// Tue Jan 01 20:30:00 CET 2008 /// Wed Jan 02 09:30:00 CET 2008
My questions are:
Why are the results always wrong
(always +1h)?
What is a better
way to identify timestamps without
day? == 70 doesn't look good and the
getDay & setDay functions are
deprecated too.
Many many thanks, this issue has been driving me crazy for several hours.

You are formatting time of day, not number of hours and minutes. As you are in the CET timezone [Central European Time] in winter, that is one hour different from UTC ("GMT").
You probably want to be using Calendar instead of Date. Or Joda-Time.

At my computer this is off by 2 hours, because I'm at GMT+2, and you're probably at GMT+1. Note that formatNew.format(end.getTime() - beg.getTime()); receives date, i.e. treats your 56 minutes as 1970-01-01-00:56:00 GMT+1. To fix this quickly, call formatNew.setTimeZone( TimeZone.getTimeZone( "GMT" ) );
For the 2nd item, you can check if format-yyyy-MM-dd failed (you catch a parse error), and this is how you know that there's no year.

Simple answer: it's inappropriate to use SimpleDateFormat to format values that represent time of day without date.
Longer answer: Java time values are a count of milliseconds since the "epoch": midnight, January 1 1970, UTC.
SimpleDateFormat assumes that you're giving it a valid timestamp, and applies a localized conversion to a date and time. I suspect that your locale is one hour off GMT (continental Europe), so that's why you're seeing results that are one hour off.
While you could fool SimpleDateFormat by setting the timezone GMT, you're probably better off displaying durations using explicit math:
int duration = 90;
System.out.printf("%02d:%02d", duration / 60, duration % 60);

First, your example strings are not consistent: 8:30 pm lacks a padding zero. I will assume that is a typo, and should have been 08:30 pm.
Undesirable string formats
By the way, these input string formats are not desirable.
- A much better way is to use standard ISO 8601 formats.
- 12-hour clocks with AM/PM are troublesome. The standard formats use 24-hour clock, with hours 0-23.
- The standard notation for an interval is the pair of date-time strings separated by a slash: 2008-01-01T13:00/2008-01-01T13:56.
Your input strings have another serious problem: No indication of offset-from-UTC or time zone. Without an offset or time zone, we must fall back to assuming generic 24-hour days. This ignores anomalies such as Daylight Saving Time (DST) that can result in 23 or 25 hour long days.
If you know the time zone intended for the incoming strings, pass that as a second argument to get a correct result.
java.time
This Question is quite old. Since then Java has supplanted the troublesome old date-time classes (Date, Calendar, etc.) with modern java.time classes. We use java.time in the example code below.
Example class
Here is a complete class for processing these strings as given in your Question. A Duration is produced.
package javatimestuff;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Locale;
/**
*
* #author Basil Bourque
*/
public class DurationProcessor {
static final int SHORT = 30;
static final int LONG = 41;
static final DateTimeFormatter FORMATTER_LOCALDATETIME = DateTimeFormatter.ofPattern ( "uuuu-MM-dd hh:mm a" );
static final DateTimeFormatter FORMATTER_LOCALTIME = DateTimeFormatter.ofPattern ( "hh:mm a" );
static public Duration process ( String input ) {
return DurationProcessor.process ( input , ZoneOffset.UTC );
}
static public Duration process ( String input , ZoneId zoneId ) {
Duration d = Duration.ZERO; // Or maybe null. To be generated by the bottom of this code.
if ( null == input ) {
// …
System.out.println ( "ERROR - Passed null argument." );
return d;
}
if ( input.length () == 0 ) {
// …
System.out.println ( "ERROR - Passed empty string as argument." );
return d;
}
String inputModified = input.toUpperCase ( Locale.ENGLISH ); // Change `am` `pm` to `AM` `PM` for parsing.
String[] parts = inputModified.split ( " - " );
String inputStart = parts[ 0 ]; // A date-time sting.
String inputStop = parts[ 1 ]; // Either a date-time string or a time-only string (assume the same date).
ZonedDateTime start = null; // To be generated in this block of code.
try {
LocalDateTime ldt = LocalDateTime.parse ( inputStart , DurationProcessor.FORMATTER_LOCALDATETIME );
start = ldt.atZone ( zoneId );
} catch ( DateTimeParseException e ) {
// …
System.out.println ( "ERROR - The start failed to parse. inputStart: " + inputStart );
return d;
}
ZonedDateTime stop = null; // To be generated in this block of code.
switch ( input.length () ) {
case DurationProcessor.SHORT: // Example: "2008-01-01 01:00 pm - 01:56 pm"
try {
LocalTime stopTime = LocalTime.parse ( inputStop , DurationProcessor.FORMATTER_LOCALTIME );
stop = ZonedDateTime.of ( start.toLocalDate () , stopTime , zoneId );
} catch ( DateTimeParseException e ) {
// …
System.out.println ( "ERROR - The stop time failed to parse." );
return d;
}
break;
case DurationProcessor.LONG: // "2008-01-01 8:30 pm - 2008-01-02 09:30 am"
try {
LocalDateTime ldt = LocalDateTime.parse ( inputStop , DurationProcessor.FORMATTER_LOCALDATETIME );
stop = ldt.atZone ( zoneId );
} catch ( DateTimeParseException e ) {
// …
System.out.println ( "ERROR - The stop date-time failed to parse." );
return d;
}
break;
default:
// …
System.out.println ( "ERROR - Input string is of unexpected length: " + input.length () );
break;
}
d = Duration.between ( start , stop );
return d;
}
public static void main ( String[] args ) {
// Run with out time zone (assumes UTC).
Duration dShort = DurationProcessor.process ( "2008-01-01 01:00 pm - 01:56 pm" );
System.out.println ( "dShort: " + dShort );
Duration dLong = DurationProcessor.process ( "2008-01-01 08:30 pm - 2008-01-02 09:30 am" );
System.out.println ( "dLong: " + dLong );
// Run with specified time zone.
ZoneId z = ZoneId.of ( "America/Montreal" );
Duration dShortZoned = DurationProcessor.process ( "2008-01-01 01:00 pm - 01:56 pm" , z );
System.out.println ( "dShortZoned: " + dShortZoned );
Duration dLongZoned = DurationProcessor.process ( "2008-01-01 08:30 pm - 2008-01-02 09:30 am" , z );
System.out.println ( "dLongZoned: " + dLongZoned );
}
}
Note the main method within the class for example usages.
First a pair of calls without specifying a time zone. So UTC and 24-hour days will be used.
Duration dShort = DurationProcessor.process ( "2008-01-01 01:00 pm - 01:56 pm" );
System.out.println ( "dShort: " + dShort );
Duration dLong = DurationProcessor.process ( "2008-01-01 08:30 pm - 2008-01-02 09:30 am" );
System.out.println ( "dLong: " + dLong );
Another pair of calls where we do specify the intended time zone.
ZoneId z = ZoneId.of ( "America/Montreal" );
Duration dShortZoned = DurationProcessor.process ( "2008-01-01 01:00 pm - 01:56 pm" , z );
System.out.println ( "dShortZoned: " + dShortZoned );
Duration dLongZoned = DurationProcessor.process ( "2008-01-01 08:30 pm - 2008-01-02 09:30 am" , z );
System.out.println ( "dLongZoned: " + dLongZoned );
Live code
See this class run in live code in IdeOne.com.
dShort: PT56M
dLong: PT13H
dShortZoned: PT56M
dLongZoned: PT13H
As noted elsewhere on this page, your output format using time-of-day style such as 00:56 is ambiguous and confusing, and should be avoided. The Duration class instead uses standard ISO 8601 format for durations. Above, we see results of fifty-six minutes and thirteen minutes.
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.
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.
Where to obtain the java.time classes?
Java SE 8 and SE 9 and later
Built-in.
Part of the standard Java API with a bundled implementation.
Java 9 adds some minor features and fixes.
Java SE 6 and SE 7
Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
Android
The ThreeTenABP project adapts ThreeTen-Backport (mentioned above) for Android specifically.
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.