openplanning

Hướng dẫn sử dụng Java Duration

Xem thêm các chuyên mục:

1- Duration

Lớp Duration đại diện cho một lượng thời gian với độ chính xác nano giây, chẳng hạn: "2 ngày 3 giờ", "2 giờ 3 phút 15 giây", "2 giây 123 nano giây",..
public final class Duration
        implements TemporalAmount, Comparable<Duration>, Serializable
  • ChronoPeriod
  • Period
  • TemporalAmount
Lớp DurationPeriod đều đại diện cho một lượng thời gian, nhưng chúng có sự khác biệt. Duration đại diện cho một lượng thời gian chính xác, trong khi đó Period đại diện cho một lượng thời gian ước lượng.
  • Duration có thể chuyển đổi thành NANOS, MILLIS, SECONDS, MINITES, HOURS hoặc DAYS, các đơn vị tính này là chính xác, với 1 ngày được coi là 24 tiếng.
  • Period hỗ trợ các đơn vị tính DAYS, MONTHS, YEARS, chúng độc lập với nhau. Nguyên nhân là các đơn vị tính này là ước lượng, chúng có độ dài không cố định.
Ví dụ:
  Example
Duration 1 days 23 hours 15 seconds
Period 3 years 5 months 1 days
Các giá trị ngày, giờ, phút, giây, mili giây, nano giây trong Duration có thể quy đổi với nhau. Chẳng hạn: "13 giờ 90 phút" sẽ bằng với "14 giờ 30 phút".
Mặc dù Duration là lớp dựa trên số lượng nano giây, nhưng để so sánh 2 đối tượng Duration bạn nên sử dụng phương thức equals(Object).

2- Factory methods

Các phương thức nhà máy tĩnh:
public static Duration ofDays(long days)  
public static Duration ofHours(long hours)  
public static Duration ofMinutes(long minutes)
public static Duration ofSeconds(long seconds)
public static Duration ofSeconds(long seconds, long nanoAdjustment)
public static Duration ofMillis(long millis)
public static Duration ofNanos(long nanos)
public static Duration of(long amount, TemporalUnit unit)
public static Duration from(TemporalAmount amount)
public static Duration parse(CharSequence text)  
public static Duration between(Temporal startInclusive, Temporal endExclusive)
Ví dụ: Tạo một Duration từ số giây và số nano giây:
Duration_ofSeconds_ex2.java
// ofSeconds(long seconds, long nanoAdjustment)
// 3 minutes 20 seconds 12345 nanoseconds.
Duration duration = Duration.ofSeconds(3*60 + 20, 12345); // 3M 20S 12345 Nanos.

System.out.println(duration); // PT3M20.000012345S
System.out.println("duration.toHoursPart(): " + duration.toHoursPart()); // 0
System.out.println("duration.toMinutesPart(): " + duration.toMinutesPart()); // 3
System.out.println("duration.toSecondsPart(): " + duration.toSecondsPart()); // 20
System.out.println("duration.toNanosPart(): " + duration.toNanosPart()); // 12345
Ví dụ: Tạo một Duration là khoảng thời gian giữa 2 đối tượng Temporal. Chú ý: Hai đối tượng Temporal này phải hỗ trợ đơn vị tính ChronoUnit.SECONDS, nếu không ngoại lệ sẽ được ném ra. Để có độ chính xác đầy đủ, ChronoUnit.NANOS hoặc ChronoField.NANO_OF_SECOND phải được hỗ trợ.
Duration_between_ex1.java
LocalDateTime localDateTime1 = LocalDateTime.of(2020, 5, 15, 13, 30, 45);
LocalDateTime localDateTime2 = LocalDate.of(2020, 5, 17).atStartOfDay();

Duration duration = Duration.between(localDateTime1, localDateTime2);

System.out.println(duration); // PT34H29M15S  (10 hours 29 minutes 15 seconds).
System.out.println("duration.toHoursPart(): " + duration.toHoursPart()); // 10
System.out.println("duration.toMinutesPart(): " + duration.toMinutesPart()); // 29
System.out.println("duration.toSecondsPart(): " + duration.toSecondsPart()); // 15

3- Other methods

Các phương thức khác:
public boolean isZero()  
public boolean isNegative()  

// -----------------------------------------------------------------
// getX()
// -----------------------------------------------------------------

// Inherited from TemporalAmount interface
public long get(TemporalUnit unit)

// Inherited from TemporalAmount interface
public List<TemporalUnit> getUnits()

public long getSeconds()  
public int getNano()  

// -----------------------------------------------------------------
// withX()
// -----------------------------------------------------------------

public Duration withSeconds(long seconds)  
public Duration withNanos(int nanoOfSecond)

// -----------------------------------------------------------------
// plusX()
// -----------------------------------------------------------------
public Duration plus(Duration duration)  
public Duration plus(long amountToAdd, TemporalUnit unit)  

public Duration plusDays(long daysToAdd)  
public Duration plusHours(long hoursToAdd)  
public Duration plusMinutes(long minutesToAdd)  
public Duration plusSeconds(long secondsToAdd)  
public Duration plusMillis(long millisToAdd)  
public Duration plusNanos(long nanosToAdd)  

// -----------------------------------------------------------------
// minusX()
// -----------------------------------------------------------------
public Duration minus(Duration duration)  
public Duration minus(long amountToSubtract, TemporalUnit unit)

public Duration minusDays(long daysToSubtract)
public Duration minusHours(long hoursToSubtract)  
public Duration minusMinutes(long minutesToSubtract)  
public Duration minusSeconds(long secondsToSubtract)  
public Duration minusMillis(long millisToSubtract)
public Duration minusNanos(long nanosToSubtract)  

// -----------------------------------------------------------------
// toX()
// -----------------------------------------------------------------

public long toDays()  
public long toHours()  
public long toMinutes()  
public long toSeconds()  
public long toMillis()  
public long toNanos()  

// -----------------------------------------------------------------
// toXPart()
// -----------------------------------------------------------------

public long toDaysPart()  
public int toHoursPart()  
public int toMinutesPart()
public int toSecondsPart()  
public int toMillisPart()  
public int toNanosPart()  

// -----------------------------------------------------------------
// Other methods:
// -----------------------------------------------------------------

public Duration truncatedTo(TemporalUnit unit)
public Duration multipliedBy(long multiplicand)
public Duration dividedBy(long divisor)
public long dividedBy(Duration divisor)
public Duration negated()  
public Duration abs()  

// Inherited from TemporalAmount interface
public Temporal addTo(Temporal temporal)

// Inherited from TemporalAmount interface
public Temporal subtractFrom(Temporal temporal)  

4- toX() *

Phương thức toNanos() trả về tổng số nano giây trong Duration này.
Các phương thức khác như toMillis(), toSeconds(), toMinutes(), toHours(), toDays() được hiểu tương tự giống như cái tên của chúng.
public long toNanos()  
public long toMillis()  
public long toSeconds()  
public long toMinutes()  
public long toHours()  
public long toDays() 
Cụ thể chúng ta có:
  • toMinutes() bằng phần nguyên của phép chia toSeconds() cho 60.
  • toHours() bằng phần nguyên của phép chia toSeconds() cho 60*60.
  • toDays() bằng phần nguyên của phép chia toSeconds() cho 24*60*60.
(*) Nếu toNanos() > Long.MAX_VALUE hoặc toMillis() > Long.MAX_VALUE thì ArithmeticException sẽ bị ném ra.
toX() Same as: Equals to Ranges
toNanos()      0-Long.MAX_VALUE
toMillis()      
toSeconds() getSeconds()  
toMinutes()   toSeconds() / 60
toHours()    toSeconds() / (60*60)
toDays()     toSeconds() / (24*60*60)
Ví dụ:
Duration_toX_ex1.java
// 10 days 10 hours 10 minutes 10 seconds.
long seconds = 10 * 24 * 60 * 60 + 10 * 60 * 60 + 10 * 60 + 10;

//
// 1 milliseconds = 10^6 nanoseconds
// 1 seconds = 10^9 nanoseconds
//
// (10 days 10 hours 10 minutes 10 seconds) + (10 milliseconds 10 nanoseconds).
long nanos = seconds * 1000000000L + 10 * 1000000L + 10L;

Duration duration = Duration.ofNanos(nanos);

System.out.println(duration); // PT250H10M10.01000001S

System.out.println("duration.toDays(): " + duration.toDays()); // 10
System.out.println("duration.toHours(): " + duration.toHours()); // 250
System.out.println("duration.toMinutes(): " + duration.toMinutes()); // 15010
System.out.println("duration.toSeconds(): " + duration.toSeconds()); // 900610
System.out.println("duration.toMillis(): " + duration.toMillis()); // 900610010
System.out.println("duration.toNanos(): " + duration.toNanos()); // 900610010000010

System.out.println("duration.getSeconds(): " + duration.getSeconds()); // 900610

5- toXPart() *

Phương thức toNanosPart() trả về phần nano giây của Duration này, giá trị này không phải là tổng số nano giây trong Duration.
Các phương thức toMillisPart(), toMinutesPart(), toHoursPart() cũng được hiểu một cách tương tự giống như cái tên của chúng.
Phương thức toDaysPart() trả về cùng một kết quả như toDays().
public int toNanosPart()  
public int toMillisPart()  
public int toSecondsPart()  
public int toMinutesPart()
public int toHoursPart()  
public long toDaysPart() 
toX() Same as: Equals to Range
toDaysPart()   toDays() toDays() 0-Long.MAX_VALUE
toHoursPart()     toHours() % 24 0-23
toMinutesPart()   toMinutes() % 60 0-59
toSecondsPart()     toSeconds() % 60 0-59
toMillisPart()     toMillis() % 10^3 0-10^3-1
toNanosPart()  getNano() toNanos() % 10^9 0-10^9-1
Ví dụ:
Duration_toXPart_ex1.java
// 10 days 10 hours 10 minutes 10 seconds.
long seconds = 10 * 24 * 60 * 60 + 10 * 60 * 60 + 10 * 60 + 10;

//
// 1 milliseconds = 10^6 nanoseconds
// 1 seconds = 10^9 nanoseconds
//
// (10 days 10 hours 10 minutes 10 seconds) + (10 milliseconds 10 nanoseconds).
long nanos = seconds * 1000000000L + 10 * 1000000L + 10;

Duration duration = Duration.ofNanos(nanos);

System.out.println(duration); // PT250H10M10.01000001S

System.out.println("duration.toDaysPart(): " + duration.toDaysPart()); // 10
System.out.println("duration.toHoursPart(): " + duration.toHoursPart()); // 10
System.out.println("duration.toMinutesPart: " + duration.toMinutesPart()); // 10
System.out.println("duration.toSecondsPart: " + duration.toSecondsPart()); // 10

System.out.println("duration.toMillisPart: " + duration.toMillisPart()); // 10
System.out.println("duration.toNanosPart: " + duration.toNanosPart()); // 10000010

System.out.println("duration.getNano(): " + duration.getNano()); // 10000010

6- isZero()

Trả về true nếu tổng số nano giây trong Duration này là 0, ngược lại trả về false.
public boolean isZero() 
Ví dụ:
Duration_isZero_ex1.java
// Duration using parse() method
Duration duration1 = Duration.parse("P0DT0H0M");
System.out.println("duration1: " + duration1); // PT0S
System.out.println("duration1.isZero(): " + duration1.isZero()); // true

Duration duration2 = Duration.parse("P0DT0H20M");
System.out.println("\nduration2: " + duration2); // PT20M
System.out.println("duration2.isZero(): " + duration2.isZero()); // false

Duration duration3 =  duration2.minus(Duration.ofMinutes(20));
System.out.println("\nduration3: " + duration3); // PT0S
System.out.println("duration3.isZero(): " + duration3.isZero()); // true

Duration duration4 =  Duration.parse("P0DT1H-60M"); // 1 hour & -60 minutes
System.out.println("\nduration4: " + duration4); // PT0S
System.out.println("duration4.isZero(): " + duration4.isZero()); // true
Output:
duration1: PT0S
duration1.isZero(): true

duration2: PT20M
duration2.isZero(): false

duration3: PT0S
duration3.isZero(): true

duration4: PT0S
duration4.isZero(): true

7- isNegative()

Trả về true nếu tổng số nano giây trong Duration này nhỏ hơn 0, ngược lại trả về false.
public boolean isNegative()  
Ví dụ:
Duration_isNegative_ex1.java
// 10 hours 10 minutes
Duration duration1 = Duration.ofMinutes(10 * 60 + 10);
// 20 hours 20 seconds
Duration duration2 = Duration.ofSeconds(20 * 60 * 60 + 20);

// duration1 - duration2
Duration duration = duration1.minus(duration2);
System.out.println("duration: " + duration); // PT-9H-50M-20S
System.out.println("duration.isNegative(): " + duration.isNegative()); // true
Output:
duration: PT-9H-50M-20S
duration.isNegative(): true

8- get(TemporalUnit)

Phương thức này chỉ hỗ trợ 2 đơn vị tính là ChronoUnit.SECONDSChronoUnit.NANOS, các đơn vị tính khác sẽ ném ra ngoại lệ.
  • get(ChronoUnit.SECONDS) trả về tổng số giây trong Duration này, nó tương đương với toSeconds().
  • get(ChronoUnit.NANOS) trả về phần nano giây trong Duration này, nó tương đương với toNanosPart(), giá trị nằm trong phạm vi từ 0 đến 10^9-1.
// Inherited from TemporalAmount interface
public long get(TemporalUnit unit)
get(TemporalUnit) Same as Example
    2 minutes 12345 nanos
get(ChronoUnit.SECONDS) toSeconds() getSeconds() 2*60 seconds
get(ChronoUnit.NANOS) toNanosPart() getNano() 12345 nanos
Ví dụ:
Duration_get_unit_ex1.java
// 2 minutes 12345 nanoseconds.
Duration duration = Duration.ofSeconds(2 * 60, 12345);
System.out.println("duration: " + duration); // PT2M0.000012345S
System.out.println();  
 
System.out.println("SECONDS: " + duration.get(ChronoUnit.SECONDS)); // 120
System.out.println("NANOS: " + duration.get(ChronoUnit.NANOS)); // 12345

9- getUnits()

Trả về các đơn vị tính được hỗ trợ bởi Duration này.
// Inherited from TemporalAmount interface
public List<TemporalUnit> getUnits()
Phương thức này luôn trả về List.of(ChronoUnit.SECONDS,ChronoUnit.NANOS).

10- getX() *

Phương thức getSeconds() trả về tổng số giây trong Duration này, nó tương tự như phương thức toSeconds().
Phương thức getNano() trả về phần nano giây của Duration này, nó giống với phương thức toNanosPart().
public long getSeconds()  
public int getNano()  
getX() Same as: Range Example
      2 minutes 12345 nanos
getSeconds() toSeconds() 0-Long.MAX_VALUE 120 seconds
getNano() toNanosPart() 0-10^9-1 12345 nano
Ví dụ:
Duration_getX_ex1.java
// 10 minutes 10 seconds 10 nanos.  (1 seconds = 10^9 nanos)
long nano = 10 * 60 * 1000000000L + 10 * 1000000000L + 10;

System.out.println("nano: " + nano); // 610000000010

Duration duration = Duration.ofNanos(nano);

System.out.println(duration); // PT10M10.00000001S

System.out.println("duration.getSeconds(): " + duration.getSeconds()); // 610
System.out.println("duration.getNano(): " + duration.getNano()); // 10

System.out.println("duration.toSeconds(): " + duration.toSeconds()); // 610
System.out.println("duration.toNanosPart(): " + duration.toNanosPart()); // 10
System.out.println("duration.toNanos(): " + duration.toNanos()); // 610000000010

11- withX(..) *

public Duration withSeconds(long seconds)  
public Duration withNanos(int nanoOfSecond)
Phương thức withSeconds(seconds) trả về một bản sao của Duration này, giữ lại phần nano giây, và thay thế tổng số giây bởi số giây đã cho.
Duration_withSeconds_ex1.java
// 10 minutes 10 seconds 99 nanos
Duration duration = Duration.ofSeconds(10 * 60 + 10, 99);
System.out.println("duration: " + duration); // PT10M10.000000099S

// with 120 seconds (2 minutes)
Duration duration1 = duration.withSeconds(120);

System.out.println("duration1: " + duration1); // PT2M0.000000099S (2 minutes 99 nanos)
Phương thức withNanos(nanos) trả về một bản sao của Duration này. Thay thế phần nano giây và giữ lại các phần khác. Tham số nanos có giá trị từ 0 đến 10^9-1.
Duration_withNanos_ex1.java
// 10 minutes 10 seconds 99 nanos
Duration duration = Duration.ofSeconds(10 * 60 + 10, 99);
System.out.println("duration: " + duration); // PT10M10.000000099S

// with 111 nanos
Duration duration1 = duration.withNanos(111);
System.out.println("duration1: " + duration1); // PT10M10.000000111S (10 minutes 10 seconds 111 nanos)

12- plus(Duration)

Cộng Duration này với một Duration được chỉ định để tạo ra một Duration mới, kết quả trả về đã được chuẩn hoá.
public Duration plus(Duration duration)  
Ví dụ:
Duration_plus_duration_ex1.java
// 20 hours 20 minutes 20 seconds
Duration duration1 = Duration.ofSeconds(20 * 60 * 60 + 20 * 60 + 20);
System.out.println("duration1: " + duration1); // PT20H20M20S

// 50 minutes 10 seconds
Duration duration2 = Duration.ofSeconds(50 * 60 + 10);
System.out.println("duration1: " + duration2); // PT50M10S

Duration duration3 = duration1.plus(duration2);
System.out.println("duration3: " + duration3); // PT21H10M30S (21 Hours 10 minutes 30 seconds) 
Output:
duration1: PT20H20M20S
duration1: PT50M10S
duration3: PT21H10M30S

13- plus(long, TemporalUnit)

Trả về một bản sao của Duration này với một lượng thời gian được thêm vào theo đơn vị tính đã cho.
public Duration plus(long amountToAdd, TemporalUnit unit)  
Chú ý: Phương thức này chỉ hỗ trợ các TemporalUnit có thời lượng chính xác, chẳng hạn ChronoUnit.DAYS tương đương với 24 giờ. ChronoUnit.MONTHS được coi là một đơn vị tính ước lượng (estimate) vì độ dài của nó khôngkhông cố định. Tóm lại một temporalUnit được hỗ trợ bởi phương thức này nếu temporalUnit.isDurationEstimated() trả về false.
Các đơn vị tính tiêu chuẩn sau được hỗ trợ:
  • ChronoUnit.NANOS
  • ChronoUnit.MICROS
  • ChronoUnit.MILLIS
  • ChronoUnit.SECONDS
  • ChronoUnit.MINUTES
  • ChronoUnit.HOURS
  • ChronoUnit.HALF_DAYS
  • ChronoUnit.DAYS
Ví dụ:
Duration_plus_unit_ex1.java
// 10 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(10 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT10H10M10S

// plus 1 DAY (24 Hours)
Duration duration2 = duration1.plus(1, ChronoUnit.DAYS);
System.out.println("duration2: " + duration2); // PT34H10M10S (34 hours 12 minutes 40 seconds)

// plus 150 Seconds  (2 minutes 30 seconds)
Duration duration3 = duration1.plus(150, ChronoUnit.SECONDS);
System.out.println("duration3: " + duration3); // PT10H12M40S (10 hours 12 minutes 40 seconds)

14- plusX(..) *

Phương thức plusNanos(nanosToAdd) trả về bản sao của Duration này với một lượng nano giây chỉ định được thêm vào.
Các phương thức khác như plusMillis(millisToAdd), plusSeconds(secondsToAdd), plusMinutes(long minutesToAdd), plusHours(hoursToAdd), plusDays(daysToAdd) cũng được hiểu theo cách tương tự giống như cái tên của chúng.
public Duration plusNanos(long nanosToAdd)  
public Duration plusMillis(long millisToAdd)  
public Duration plusSeconds(long secondsToAdd)  
public Duration plusMinutes(long minutesToAdd)  
public Duration plusHours(long hoursToAdd)  
public Duration plusDays(long daysToAdd)
Ví dụ:
Duration_plusX_ex1.java
// 10 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(10 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT10H10M10S

// plus 150 seconds. (2 minutes 30 seconds)
Duration duration2 = duration1.plusSeconds(150);
System.out.println("duration2: " + duration2); // PT10H12M40S (10 hours 12 minutes 40 seconds)

// plus -30 minutes.
Duration duration3 = duration1.plusMinutes(-30);
System.out.println("duration3: " + duration3); // PT9H40M10S (9 hours 10 minutes 10 seconds)

15- minus(Duration)

Trừ một Duration chỉ định ra khỏi Duration này và trả về một Duration mới, kết quả trả về đã được chuẩn hoá.
public Duration minus(Duration duration)  
Ví dụ:
Duration_minus_duration_ex1.java
// 20 hours 20 minutes 20 seconds
Duration duration1 = Duration.ofSeconds(20 * 60 * 60 + 20 * 60 + 20);
System.out.println("duration1: " + duration1); // PT20H20M20S

// 50 minutes 10 seconds
Duration duration2 = Duration.ofSeconds(50 * 60 + 10);
System.out.println("duration2: " + duration2); // PT50M10S

// duration1 - duration2
Duration duration3 = duration1.minus(duration2);
System.out.println("duration3: " + duration3); // PT19H30M10S (19 Hours 30 minutes 10 seconds) 
Output:
duration1: PT20H20M20S
duration2: PT50M10S
duration3: PT19H30M10S

16- minus(long, TemporalUnit)

Trả về một bản sao của Duration này với một lượng thời gian được trừ đi theo đơn vị tính đã cho.
public Duration minus(long amountToSubtract, TemporalUnit unit)
Chú ý: Phương thức này chỉ hỗ trợ các TemporalUnit có thời lượng chính xác, chẳng hạn ChronoUnit.DAYS tương đương với 24 giờ. ChronoUnit.MONTHS được coi là một đơn vị tính ước lượng (estimate) vì độ dài của nó khôngkhông cố định. Tóm lại một temporalUnit được hỗ trợ bởi phương thức này nếu temporalUnit.isDurationEstimated() trả về false.
Các đơn vị tính tiêu chuẩn sau được hỗ trợ:
  • ChronoUnit.NANOS
  • ChronoUnit.MICROS
  • ChronoUnit.MILLIS
  • ChronoUnit.SECONDS
  • ChronoUnit.MINUTES
  • ChronoUnit.HOURS
  • ChronoUnit.HALF_DAYS
  • ChronoUnit.DAYS
Ví dụ:
Duration_minus_unit_ex1.java
// 25 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(25 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT25H10M10S

// minus 1 DAY (24 Hours)
Duration duration2 = duration1.minus(1, ChronoUnit.DAYS);
System.out.println("duration2: " + duration2); // PT1H10M10S (1 hours 10 minutes 10 seconds)

// minus 150 Seconds  (2 minutes 30 seconds)
Duration duration3 = duration1.minus(150, ChronoUnit.SECONDS);
System.out.println("duration3: " + duration3); // PT25H7M40S (25 hours 7 minutes 40 seconds)

17- minusX(..) *

Phương thức minusNanos(nanosToSubtract) trả về bản sao của Duration này với một lượng nano giây chỉ định được trừ đi.
Các phương thức khác như minusMillis(millisToSubtract), minusSeconds(secondsToSubtract), minusMinutes(long minutesToSubtract), minusHours(hoursToSubtract), minusDays(daysToSubtract) cũng được hiểu theo cách tương tự giống như cái tên của chúng.
public Duration minusNanos(long nanosToSubtract)  
public Duration minusMillis(long millisToSubtract)
public Duration minusSeconds(long secondsToSubtract)  
public Duration minusMinutes(long minutesToSubtract)  
public Duration minusHours(long hoursToSubtract)  
public Duration minusDays(long daysToSubtract)
Ví dụ:
Duration_minusX_ex1.java
// 10 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(10 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT10H10M10S

// minus 30 seconds.
Duration duration2 = duration1.minusSeconds(30);
System.out.println("duration2: " + duration2); // PT10H7M40S (10 hours 9 minutes 40 seconds)

18- truncatedTo(TemporalUnit)

Trả về một bản sao của đối tượng Duration này bị cắt cụt (truncated) tới đơn vị tính chỉ định.
public Duration truncatedTo(TemporalUnit unit)
Phương thức này hỗ trợ đơn vị tính ChronoUnit.DAYS và và tất cả các đơn vị tính dựa trên thời gian (time-based) nghĩa là temporalUnit.isTimeBased()true. Các đơn vị tính khác sẽ ném ra ngoại lệ.
Ví dụ:
Duration_truncatedTo_ex1.java
// 10 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(10 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT10H10M10S

// Truncated to ChronoUnit.MINUTES
Duration duration2 = duration1.truncatedTo(ChronoUnit.MINUTES);
System.out.println("duration2: " + duration2); // PT10H10M (10 hours 10 minutes)

19- negated()

Trả về một bản sao phủ định của Duration này. Nghĩa là phép cộng của Duration được trả về và Duration này bằng 0.
public Duration negated()  
Ví dụ:
Duration_negated_ex1.java
// 20 hours 20 minutes 20 seconds
Duration duration1 = Duration.ofSeconds(20 * 60 * 60 + 20 * 60 + 20);
System.out.println("duration1: " + duration1); // PT20H20M20S

// duration2 = 0 - duration1
Duration duration2 = duration1.negated();
System.out.println("duration2: " + duration2); // PT-20H-20M-20S 

20- abs()

Trả về bản sao giá trị tuyệt đối của Duration này, điều này có nghĩa là độ dài của Duration được trả về có giá trị dương.
public Duration abs()  
Ví dụ:
Duration_abs_ex1.java
// -20 hours, 20 minutes, -20 seconds
Duration duration1 = Duration.parse("PT-20H20M-20S");
System.out.println("duration1: " + duration1); // PT-19H-40M-20S (-19H, -40M, -20S)

// duration2 = duration1 < 0 ? -duration1 : duration1;
Duration duration2 = duration1.abs();
System.out.println("duration2: " + duration2); // PT19H40M20S (19H 40M 20S)

21- addTo(Temporal)

Thêm Duration này vào một đối tượng Temporal được chỉ định và trả về bản sao của đối tượng Temporal này.
// Inherited from TemporalAmount interface
public Temporal addTo(Temporal temporal)
Phương thức này tương đương với phương thức Temporal.plus(TemporalAmount).
Temporal copiedTemporal = temporal.plus(duration);

Temporal copiedTemporal = duration.addTo(temporal);
Ví dụ:
Duration_addTo_ex1.java
// Create Temporal object.
LocalDateTime localDateTime = LocalDateTime.of(1985, 12, 31, 23, 30, 0);
System.out.println("localDateTime: " + localDateTime); // 1985-12-31T23:30

// 1 Hour
Duration duration = Duration.ofHours(1);

LocalDateTime newLocalDateTime = (LocalDateTime) duration.addTo(localDateTime);
System.out.println("newLocalDateTime: " + newLocalDateTime); // 1986-01-01T00:30
Ngày 1 tháng 1 năm 1986, chính quyền Nepal đã công bố múi giờ của mình là +5h45 GMT. Điều đó đồng nghĩa với việc họ đang nhanh hơn nước láng giềng Ấn Độ 15 phút. Động thái này nhằm tạo ra sự khác biệt với người hàng xóm khổng lồ và thể hiện sự tự hào dân tộc của người Nepal.
Như vậy, ngày 1 tháng 1 năm 1986, lúc 0 giờ 0 phút 0 giây tại Ấn Độ tương đương với 0 giờ 15 phút 0 giây tại Nepal. Người Nepal đã vặn đồng hồ của họ nhanh hơn 15 phút so với Ấn Độ.
Chúng ta sẽ xem điều gì xẩy ra tại thời điểm 23 giờ 30 phút ngày 31 tháng 12 năm 1985 tại Nepal, và sau đó 1 giờ:
Duration_addTo_ex2.java
ZoneId nepalZoneId = ZoneId.of("Asia/Kathmandu");

// Create Temporal object.
ZonedDateTime zonedDateTime = ZonedDateTime.of(1985, 12, 31, 23, 30, 0, 0, nepalZoneId);
System.out.println("zonedDateTime: " + zonedDateTime); // 1985-12-31T23:30+05:30[Asia/Kathmandu]

// 1 Hour
Duration duration = Duration.ofHours(1);

ZonedDateTime newZonedDateTime = (ZonedDateTime) duration.addTo(zonedDateTime);
System.out.println("newZonedDateTime: " + newZonedDateTime); // 1986-01-01T00:45+05:45[Asia/Kathmandu]
Output:
zonedDateTime: 1985-12-31T23:30+05:30[Asia/Kathmandu]
newZonedDateTime: 1986-01-01T00:45+05:45[Asia/Kathmandu]

22- subtractFrom(Temporal)

Trừ Duration này ra khỏi đối tượng Temporal được chỉ định và trả về bản sao của đối tượng Temporal này.
// Inherited from TemporalAmount interface
public Temporal subtractFrom(Temporal temporal)  
Phương thức này tương đương với phương thức Temporal.minus(TemporalAmount).
Temporal copiedTemporal = temporal.minus(duration);

Temporal copiedTemporal = duration.subtractFrom(temporal);
Ví dụ:
Duration_subtractFrom_ex1.java
// Create Temporal object.
LocalDateTime localDateTime = LocalDateTime.of(2000, 1, 1, 0, 30, 0);
System.out.println("localDateTime: " + localDateTime); // 2000-01-01T00:30

// 1 Hour
Duration duration = Duration.ofHours(1);

LocalDateTime newLocalDateTime = (LocalDateTime) duration.subtractFrom(localDateTime);
System.out.println("newLocalDateTime: " + newLocalDateTime); // 1999-12-31T23:30

23- multipliedBy(long)

Phép nhân Duration này với một giá trị chỉ định và trả về một Duration mới. Kết quả trả về đã được chuẩn hoá.
public Duration multipliedBy(long multiplicand)
Ví dụ:
Duration_multipliedBy_ex1.java
// 30 minutes 25 seconds
Duration duration1 = Duration.ofSeconds(30 * 60 + 25);
System.out.println("duration1: " + duration1); // PT30M25S

// duration2 = duration1 * 2
Duration duration2 = duration1.multipliedBy(2);
System.out.println("duration2: " + duration2); // PT1H50S (1 Hour 50 seconds)

24- dividedBy(long)

Phép chia Duration này cho một giá trị chỉ định và trả về một Duration mới. Kết quả trả về đã được chuẩn hoá.
public Duration dividedBy(long divisor)
Ví dụ:
Duration_dividedBy_ex1.java
// 1 hour 30 minutes 25 seconds
Duration duration1 = Duration.ofSeconds(1 * 60 * 60 + 30 * 60 + 25);
System.out.println("duration1: " + duration1); // PT1H30M25S

// duration2 = duration1 / 2
Duration duration2 = duration1.dividedBy(2);
System.out.println("duration2: " + duration2); // PT45M12.5S (45 minutes 12.5 seconds)

25- dividedBy(Duration)

Phép chia Duration này cho một Duration khác và trả về một số nguyên.
public long dividedBy(Duration divisor)
Ví dụ:
Duration_dividedBy_ex2.java
// 1 hour 30 minutes 25 seconds
Duration duration1 = Duration.ofSeconds(1 * 60 * 60 + 30 * 60 + 25);
System.out.println("duration1: " + duration1); // PT1H30M25S
System.out.println("duration1.toNanos(): " + duration1.toNanos()); // 5425000000000

// 1 minute 30 seconds
Duration duration2 = Duration.ofSeconds(1 * 60 + 30);
System.out.println("duration2: " + duration2); // PT1M30S
System.out.println("duration2.toNanos(): " + duration2.toNanos()); // 90000000000

// duration1 / duration2
long result1 = duration1.dividedBy(duration2);
double result2 = (double) duration1.toNanos() / duration2.toNanos();
System.out.println("result1: " + result1); // 60
System.out.println("result2: " + result2); // 60.27777777777778

Xem thêm các chuyên mục:

Có thể bạn quan tâm

Đây là các khóa học trực tuyến bên ngoài website o7planning mà chúng tôi giới thiệu, nó có thể bao gồm các khóa học miễn phí hoặc giảm giá.