As can be found on the English Wikipedia’s article about ISO 8601 (Date and time — Representations for information interchange):

• P is the duration designator (for period) placed at the start of the duration representation.
  • Y is the year designator that follows the value for the number of years.
  • M is the month designator that follows the value for the number of months.
  • W is the week designator that follows the value for the number of weeks.
  • D is the day designator that follows the value for the number of days.
• T is the time designator that precedes the time components of the representation.

So P means 'Period', and because there are no 'date'-components. It only has a 'time'.

You could interpret this as 'Period of Time'.

The 'why' this was chosen, you have to ask the ISO members that wrote the standard, but my guess is that it is easier to parse (short and unambiguous).

The details for the time component are:

• H is the hour designator that follows the value for the number of hours.
• M is the minute designator that follows the value for the number of minutes.
• S is the second designator that follows the value for the number of seconds.

The value of PT20S then parses to:

• Period
• Time
• 20
• Seconds.

So, a duration of 20 seconds.

More examples can be found in the Java 25 documentation.

Addendum: Wikipedia gives a reason for T:

To resolve ambiguity, "P1M" is a one-month duration and "PT1M" is a one-minute duration (note the time designator, T, that precedes the time value).

No, it's not a bug.

According to documentation maxAge attribute is type java.time.Duration. So, what you see is toString() representation of Duration object.

Duration toString() returns a string representation of duration using ISO-8601 seconds based representation, such as PT8H6M12.345S.

The format of the string will be PTnHnMnS, where n is the relevant hours, minutes or seconds part of the duration.

Examples:

"20.345 seconds"                 -- "PT20.345S
"15 minutes" (15 * 60 seconds)   -- "PT15M"
"10 hours" (10 * 3600 seconds)   -- "PT10H"
"2 days" (2 * 86400 seconds)     -- "PT48H"

So 7 days will have 7*24 hours which is 168 hours in total, which will be described using above schema as : PT168H

tl;dr

Instant.parse( "2016-12-23T01:23:45Z" )
       .plusNanos( Math.round( 
           yourNumberOfMinutesAsDouble * 
           TimeUnit.MINUTES.toNanos( 1 ) ) 
        ) 

Avoid old date-time classes.

Actually, you should using neither java.util.Date nor java.util.Calendar. These old legacy classes are notoriously troublesome, confusing, and flawed. Now supplanted by the java.time classes.

For the old classes, the Answer by Jireugi is correct. For java.time classes, read on.

Avoid using a fractional number for elapsed time

Not a good idea using a double or Double to represent elapsed time. Firstly, that type uses floating-point technology which trades away accuracy for speed of execution. So you will often have extraneous extra digits to the right of your decimal fraction.

Secondly, this is an awkward way to handle time, given that we have sixty seconds to a minute, and sixty minutes to an hour, and so on.

• In Java, use the Period or Duration classes. See Oracle Tutorial.
• In text, use the standard ISO 8601 format PnYnMnDTnHnMnS where P marks the beginning and T separates the years-months-days from the hours-minutes-seconds. So two and a half minutes would be PT2M30S.

Nanoseconds

If we must work with the Double as a number of minutes for elapsed time, let’s convert from your fractional decimal number to a whole number (integer).

Note that the old legacy date-time classes are limited to a resolution of milliseconds while the java.time classes can go as fine as nanoseconds. So we want to convert your Double to a whole number of nanoseconds.

Rather than hard-code a magic number of the number of nanoseconds in a minute for this calculation, let's use the TimeUnit enum. That class can calculate the number of nanoseconds in a minute for us ( 60 * 1_000_000_000L ).

Finally, the Math.round function returns the closest long to the argument, with ties rounding to positive infinity.

long nanoseconds = Math.round( 
    yourNumberOfMinutesAsDouble * 
    TimeUnit.MINUTES.toNanos( 1 ) 
);

Instant

If working with date-time values in UTC, use the Instant class. Each Instant represents a moment on the timeline in UTC with a resolution of nanoseconds.

Instant Instant.parse( "2016-12-23T01:23:45Z" )
Instant future = Instant.plusNanos( nanoseconds ); 

Duration

Rather than passing around a Double as your elapsed time, I strongly suggest you pass around Duration objects.

Duration duration = Duration.ofNanos( Math.round( yourNumberOfMinutesAsDouble * TimeUnit.MINUTES.toNanos( 1 ) ) );

You can do math with a Duration such as plus and minus.

Instant instant = Instant.parse( "2016-12-23T01:23:45Z" )
Instant future = instant.plus( duration );

You can generate a String representation of the Duration in standard ISO 8601 format such as PT8H6M12.345S by merely calling toString. And Duration can parse such strings as well.

String output = duration.toString(); // PT8H6M12.345S

…or going the other direction…

Duration duration = Duration.parse( "PT8H6M12.345S" );

Try:

String iso = Duration.ofMillis(millis).toString();

toString() returns the duration using the ISO-8601 seconds based representation