Klasa java.time.Duration

Obiekt klasy reprezentuje czas trwania (odcinek czasu). Odcinek ten nie ma odniesienia do konkretnej daty określającej początek albo koniec tego odcinka czasu Obiekt posiada pole long określające liczbę sekund oraz pole int reprezentujące odcinek czasu liczony w nanosekundach. Jednostka DAYS pozwala na podanie czasu w dniach zamiast w sekundach – wówczas przez dzień rozumie się dokładnie 24 godz.
Odcinek czasu może być liczbą ujemną.
Dokładne znaczenie sekundy jest wytłumaczone w klasie Instant.
Przy porównywaniu obiektów Duration należy używać metody equals.
Obiekt jest nie mutowalny (niezmienny) i bezpieczny wątkowo.
Klasa posiada posiada statyczne pole Duration.ZERO
Klasa ma rozliczne metody do obsługi obiektów.

Metody

Metody klasy java.time.Duration
Zwraca Metoda Opis Listing
Duration abs() Zwraca kopię po obliczeniu wartości absolutnej 100
Temporal addTo(Temporal) Dodaje ten czas trwania do podanego obiektu Temporal 104
int compareTo(Duration) Porównuje ten obiekt z podanym obiektem. Zwraca ), gdy są jednakowe, 1 gdy pierwszy jest większy, -1 gdy pierwszy jest krótszy. 101
Duration dividedBy(long) Zwraca kopię obiektu po podzieleniu przez long. 105
boolean equals (Object) porównuje ten czas trwania z podanym. Zwraca true jeśli są równe, false w przeciwnym przypadku 101
long get(TemporalUnit) Podaje czas trwania przeliczony na podaną jednostkę. Można pobrać wyłącznie sekundy i nanosekundy 102
int getNano() Zwraca liczę nanosekund w sekundzie tego obiektu 103
long getSeconds() Zwraca liczbę sekund w tym odcinku czasu 103
List<TemporalUnit> getUnits() Zwraca listę jednostek czasu dostarczanych przez ten obiekt Duration 103
boolean isNegative() Zwraca true, jeśli odcinek czasu jest ujemny (nie bierze pod uwagę zera) 103
boolean isZero() Zwraca true, jeśli ten odcinek czasu jest zerowy 103
Duration minus(Duration) Zwraca kopię po odjęciu podanego odcinka czasu 101
Duration minus(long, TemporalUnit) Zwraca kopię po odjęciu podanej liczby podanych jednostek czasowych 104
Duration

minusDays(long)
minusHours(long)
minusMinutes(long)
minusSeconds(long)
minusMillis(long)minusNanos(long)

Zwraca kopię po odjęciu wskazanej liczby jednostek czasowych określonych w nazwie metody. W przypadku dni są to 24-godzinne dni 104
Duration multipliedBy(long) Zwraca kopię obiektu po wcześniejszym pomnożeniu przez podaną liczbę 105
Duration negated() Zwraca kopię po zmianie znaku. 104
Duration plus(Duration) Zwraca kopię obiektu po wcześniejszym dodaniu podanego odcinka czasowego 102
Duration plus(long, TemporalUnit) Zwraca kopię obiektu po wcześniejszym dodaniu podane liczby podanych jednostek czasowych 102
Duration

plusDays(long)
plusHours(long)
plusMinutes(long)
plusSeconds(long)
plusMillis(long)
plusNanos(long)

Zwraca kopię obiektu po wcześniejszym dodaniu podanej liczby jednostek czasu wskazanych w nazwie metody. 102
Temporal substractFrom(Temporal) Odejmuje ten czas trwania od podanego obiektu Temporal 104
long

toDays()
toHours()
toMinutes()
toSeconds()
to Millis()
toNanos()

Oblicza ile podanych w nazwie metody jednostek czasu mieści się w tym czasie trwania i zwraca tę liczbę 101
String toString() Podanej ten obiekt jako łańcuch znaków zgodnie z normą ISO-8601 np. jako PT8H6M12.345S 106
Dration withNanos (int) Zwraca kopię tego okresu czasu z podaną liczbą nanosekund 106
Duration withSeconds(long) Zwraca kopię tego okresu czasu z podaną ilością sekund 106

Metody statyczne

Metody statyczne klasy java.time.Duration
Zwraca Metoda Opis Listing
Duration Duration.between(Temporal t1, temporal t2) Oblicza i zwraca odcinek czasu Duration pomiędzy t1 (włączony), a t2 (wyłączony) 100
Duration Duration.from(TemporalAmount) Przelicza podaną ilość czasu (np. Period) i zwraca jako obiekt Duration.
Duration Duration.of(long, TemporalUnit) Przelicza podaną liczbę podanych jednostek czasu i zwraca jako obiekt Duration 102
Duration

Duration.ofDays(long)
Duration.ofHours(long)
Duration.ofMinutes(long)
Duration.ofSeconds(long)
Duration.ofMillis(long)
Duation.ofNanos(long)

Przelicza podaną liczbę jednostek czasu określonych w nazwie metody i zwraca jako obiekt Duration 102
Duration Duration.ofSeconds(long sec, long nano) Przelicza podaną liczbę sekund na obiekt Duration z uwzględnieniem podanej liczby nanosekund 105
Duration Duration.parse(CharSequence) Parsuje podany tekst (w formacie PnDTnHnMn.nS) i zwraca jako obiekt Duration. Objaśnienia w rozdziale poświęconej normie ISO-8601:2004 106

Listingi

Listing100
package dt20.java_time_duration;
import java.time.*;
public class Listing100 {
    public static void main(String[] args) {
        //Podajemy datę urodzenia
        LocalDateTime born = LocalDateTime.of(1952, 6, 4, 18, 30);
        //Uzyskujemy chwilę bieżącą
        LocalDateTime today = LocalDateTime.now();
        //Obliczamy odcinek czasu między urodzinami a teraz
        Duration d1 = Duration.between(born, today);
        //Drukujemy na konsoli.
        System.out.println("d1: " + d1);
        //Obliczamy odcinek czasu od teraz do urodzin
        Duration d2 = Duration.between(today, born);
        //Drukujemy na konsoli.
        System.out.println("d2: " + d2);
        //Obliczamy wartość absolutną
        Duration d3 = d2.abs();
        //Drukujemy na konsoli
        System.out.println("d3: " + d3);
    }
}
Listing101
package dt20.java_time_duration;
import java.time.*;
public class Listing101 {
    public static void main(String[] args) {
        //Podajemy datę urodzenia
        LocalDateTime born1 = LocalDateTime.of(1952, 6, 4, 18, 30);
        LocalDateTime born2 = LocalDateTime.of(1983, 1, 17, 21, 5);
        //Uzyskujemy chwilę bieżącą
        LocalDateTime today = LocalDateTime.now();
        //Obliczamy odcinek czasu między urodzinami a teraz
        Duration d1 = Duration.between(born1, today);
        Duration d2 = Duration.between(born2, today);
        //Porównujemy obiekty
        boolean b1 = d1.equals(d2);
        int comp1 = d1.compareTo(d2);
        System.out.println("b1: " + b1);
        System.out.println("comp1: " + comp1);
        //Odejmujemy odcinek 2 do 1
        Duration d3 = d1.minus(d2);
        System.out.println("d3: " + d3);
        //Obliczamy ile to dni
        long dl = d3.toDays();
        System.out.println("d1: " + dl);
    }
}
Listing102
package dt20.java_time_duration;
import java.time.*;
import java.time.temporal.*;
public class Listing102 {
    public static void main(String[] args) {
        //Tworzymy odcinek czasu równy 1000 dni
        Duration d1 = Duration.of(1000, ChronoUnit.DAYS);
        System.out.println("d1: " + d1);
        //Tworzymy odcinek czasu równy 1000 godzin
        Duration d2 = Duration.ofHours(1000);
        System.out.println("d2: " + d2);
        //Dodajemy odcinki czasu
        Duration d3 = d1.plus(d2);
        System.out.println("d3: " + d3);
        //Dodajemy trzy godziny
        Duration d4 = d3.plusDays(3);
        System.out.println("d4: " + d4);
        //Przeliczamy na sekundy
        long len1 = d4.get(ChronoUnit.SECONDS);
        System.out.println("len 1: " + len1);
        //Dodajemy trzy dni
        Duration d5 = d4.plus(3, ChronoUnit.DAYS);
        System.out.println("d5: " + d5);
    }
}
Listing103
package dt20.java_time_duration;
import java.time.*;
import java.time.temporal.*;
import java.util.*;
public class Listing103 {
    public static void main(String[] args) {
        //Podajemy datę urodzenia
        LocalDateTime born = LocalDateTime.of(1952, 6, 4, 18, 30);
        //Uzyskujemy chwilę bieżącą
        LocalDateTime today = LocalDateTime.now();
        //Obliczamy odcinek czasu między urodzinami a teraz
        Duration d1 = Duration.between(born, today);
        //Drukujemy na konsoli.
        System.out.println("d1: " + d1);
        //Pobieramy sekundy
        long s1 = d1.getSeconds();
        System.out.println("s1: " + s1);
        //pobieramy nanosekundy
        long n1 = d1.getNano();
        System.out.println("n1: " + n1);
        List<TemporalUnit> list = d1.getUnits();
        System.out.println("list: " + list);
        //Sprawdzamy czy odcinek czasu jest ujemny
        boolean b1 = d1.isNegative();
        System.out.println("b1: " + b1);
        //Sprawdzamy czy odcinek czasu jest zerowy
        boolean b2 = d1.isZero();
        System.out.println("b2: " + b2);
    }
}
Listing104
package dt20.java_time_duration;
import java.time.*;
import java.time.temporal.*;
public class Listing104 {
    public static void main(String[] args) {
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
        //Tworzymy odcinek czasowy 1000 dni
        Duration d1 = Duration.of(1000, ChronoUnit.DAYS);
        System.out.println("d1: " + d1);
        //Dodajemy d1 do today
        LocalDateTime tomorow = (LocalDateTime) d1.addTo(today);
        System.out.println("tomorow: " + tomorow);
        //Odejmujemy d1 pd tomorow
        LocalDateTime today2 = (LocalDateTime) d1.subtractFrom(tomorow);
        System.out.println("today2: " + today2);
        //Odejmujemy 4 dni od d1
        Duration d2 = d1.minus(4, ChronoUnit.DAYS);
        System.out.println("d2: " + d2);
        //Odejmujemy jeszcze 4 godziny
        Duration d3 = d2.minusHours(4);
        System.out.println("d3: " + d3);
        //negujemy d3
        Duration d4 = d3.negated();
        System.out.println("d4: " + d4);
    }
}
Listing105
package dt20.java_time_duration;
import java.time.*;
import java.time.temporal.*;
public class Listing105 {
    public static void main(String[] args) {
        //Tworzymy okres czasu 1000 sek i 1000000 nano
        Duration d1 = Duration.ofSeconds(1000, 1000000);
        System.out.println("d1: " + d1);
        //Mnożymy ten odcinek czasu przez 1000
        Duration d2 = d1.multipliedBy(1000);
        System.out.println("d2: " + d2);
        //Dzielimy d2 przez 10000
        Duration d3 = d2.dividedBy(10000);
        System.out.println("d3: " + d3);
        //Ustalamy liczbę sekund dla d3 na 300
        Duration d4 = d3.withSeconds(300);
        System.out.println("d4: " + d4);
        //Ustalamy liczbę nanosekund dla d4 na 200
        Duration d5 = d4.withNanos(200);
        System.out.println("d5: " + d5);
        //Tworzymy odcinek czasu z ilości czasu
        Duration d6 = Duration.from(Duration.of(1000, ChronoUnit.SECONDS));
        System.out.println("d6: " + d6);
    }
}
Listing106
package dt20.java_time_duration;
import java.time.*;
public class Listing106 {
    public static void main(String[] args) {
        //Podajemy datę urodzenia
        LocalDateTime born = LocalDateTime.of(1952, 6, 4, 18, 30);
        //Uzyskujemy chwilę bieżącą
        LocalDateTime today = LocalDateTime.now();
        //Obliczamy odcinek czasu między urodzinami a teraz
        Duration d1 = Duration.between(born, today);
        //Drukujemy na konsoli.
        String str = d1.toString();
        System.out.println("str: " + str);
        Duration d2 = Duration.parse(str);
        System.out.println("d2: " + d2);
    }
}

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *