Java Language
Ora locale

Sintassi

• LocalTime time = LocalTime.now (); // Inizializza con l'orologio di sistema corrente
• LocalTime time = LocalTime.MIDNIGHT; // 00:00
• LocalTime time = LocalTime.NOON; // 12:00
• LocalTime time = LocalTime.of (12, 12, 45); // 12:12:45

Parametri

Osservazioni

Modifica del tempo

Puoi aggiungere ore, minuti, secondi e nanosecondi:

LocalTime time = LocalTime.now();
LocalTime addHours = time.plusHours(5); // Add 5 hours
LocaLTime addMinutes = time.plusMinutes(15) // Add 15 minutes
LocalTime addSeconds = time.plusSeconds(30) // Add 30 seconds
LocalTime addNanoseconds = time.plusNanos(150_000_000) // Add 150.000.000ns (150ms)

Fusi orari e loro differenza di orario

import java.time.LocalTime;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;

public class Test {
    public static void main(String[] args)
    {
            ZoneId zone1 = ZoneId.of("Europe/Berlin");
            ZoneId zone2 = ZoneId.of("Brazil/East");

            LocalTime now = LocalTime.now();
            LocalTime now1 = LocalTime.now(zone1);
            LocalTime now2 = LocalTime.now(zone2);
            
            System.out.println("Current Time : " + now);
            System.out.println("Berlin Time : " + now1);
            System.out.println("Brazil Time : " + now2);
            
            long minutesBetween = ChronoUnit.MINUTES.between(now2, now1);
            System.out.println("Minutes Between Berlin and Brazil : " + minutesBetween +"mins");          
    }
}

Quantità di tempo tra due LocalTime

Ci sono due modi equivalenti per calcolare la quantità di unità di tempo tra due LocalTime : (1) attraverso il metodo until(Temporal, TemporalUnit) e attraverso (2) TemporalUnit.between(Temporal, Temporal) .

import java.time.LocalTime;
import java.time.temporal.ChronoUnit;

public class AmountOfTime {

    public static void main(String[] args) {

        LocalTime start = LocalTime.of(1, 0, 0); // hour, minute, second
        LocalTime end = LocalTime.of(2, 10, 20); // hour, minute, second
        
        long halfDays1 = start.until(end, ChronoUnit.HALF_DAYS); // 0
        long halfDays2 = ChronoUnit.HALF_DAYS.between(start, end); // 0
        
        long hours1 = start.until(end, ChronoUnit.HOURS); // 1
        long hours2 = ChronoUnit.HOURS.between(start, end); // 1
        
        long minutes1 = start.until(end, ChronoUnit.MINUTES); // 70
        long minutes2 = ChronoUnit.MINUTES.between(start, end); // 70
        
        long seconds1 = start.until(end, ChronoUnit.SECONDS); // 4220
        long seconds2 = ChronoUnit.SECONDS.between(start, end); // 4220
        
        long millisecs1 = start.until(end, ChronoUnit.MILLIS); // 4220000
        long millisecs2 = ChronoUnit.MILLIS.between(start, end); // 4220000

        long microsecs1 = start.until(end, ChronoUnit.MICROS); // 4220000000
        long microsecs2 = ChronoUnit.MICROS.between(start, end); // 4220000000

        long nanosecs1 = start.until(end, ChronoUnit.NANOS); // 4220000000000
        long nanosecs2 = ChronoUnit.NANOS.between(start, end); // 4220000000000
        
        // Using others ChronoUnit will be thrown UnsupportedTemporalTypeException.
        // The following methods are examples thereof.
        long days1 = start.until(end, ChronoUnit.DAYS); 
        long days2 = ChronoUnit.DAYS.between(start, end); 
    }
}

Intro

LocalTime è una classe immutabile e sicura per i thread, utilizzata per rappresentare il tempo, spesso vista come ora-min-sec. Il tempo è rappresentato con precisione al nanosecondo. Ad esempio, il valore "13: 45.30.123456789" può essere memorizzato in un LocalTime.

Questa classe non memorizza o rappresenta una data o un fuso orario. Invece, è una descrizione dell'ora locale vista su un orologio da parete. Non può rappresentare un istante sulla linea del tempo senza informazioni aggiuntive come un offset o un fuso orario. Questa è una classe basata sul valore, il metodo equals dovrebbe essere usato per i confronti.

campi

MAX: la durata massima supportata di LocalTime, '23: 59: 59.999999999 '. MEZZANOTTE, MIN, NOON

Metodi statici importanti

now (), now (Clock clock), now (ZoneId zone), parse (CharSequence text)

Metodi di istanza importanti

isAfter (LocalTime altro), isBefore (LocalTime altro), meno (TemporalAmount amountToSubtract), meno (long amountToSubtract, unità TemporalUnit), più (TemporalAmount amountToAdd), più (long amountToAdd, unità TemporalUnit)

ZoneId zone = ZoneId.of("Asia/Kolkata");
LocalTime now = LocalTime.now();
LocalTime now1 = LocalTime.now(zone);
LocalTime then = LocalTime.parse("04:16:40");

La differenza di tempo può essere calcolata in uno dei seguenti modi

long timeDiff = Duration.between(now, now1).toMinutes();
long timeDiff1 = java.time.temporal.ChronoUnit.MINUTES.between(now2, now1);

Puoi anche aggiungere / sottrarre ore, minuti o secondi da qualsiasi oggetto di LocalTime.

meno ore (lunghe oreToSubtract), menoMinute (lunghe oreToMinutes), minusNanos (lunghe nanosToSubtract), minusSeconds (lunghi secondiToSubtract), plusHours (lunghe oreToSubtract), plusMinutes (lunghe oreToMinutes), plusNanos (long nanosToSubtract), plusSeconds (long secondsToSubtract)

now.plusHours(1L);
now1.minusMinutes(20L);