Sådan får du det aktuelle tidsstempel i Java

I Java er det nemt at få det aktuelle tidsstempel. Vi lærer, hvordan man erhverver tidsstemplet ved hjælp af Dato- og Timestamp-klasserne i denne lektion. Denne artikel giver nogle Java-eksempler til at få den aktuelle dato, klokkeslæt eller tidsstempel. Derudover er Java 8 inkluderet.

Tidsstemplet repræsenterer datoen og klokkeslættet for en hændelse. Det kan være datoen og klokkeslættet, hvor et bestemt input eller output blev lavet, eller enhver anden intern computerhændelse, såsom tilføjelse af specifikke data til en database på computere. Nus tidsstempel er det aktuelle tidsstempel. Hvis en hændelse indtræffer nu, og tidsstemplet er registreret, vil tidsstemplet være det i går i morgen.

Et lokalt tidsstempel, GMT-tidsstempel og UTC-tidsstempel er alle tilgængelige. Det lokale tidsstempel er det dato-klokkeslæt, der bruges til dit lands juridiske, kommercielle og sociale formål. Referencen for GMT- og UTC-tidsstempler er den samme. En tidszone er en landeforskydning, der kan anvendes på UTC for at få din lokale tid. En tidszone på +03:30 betyder, at UTC er blevet forlænget med 3 timer og 30 minutter.

År, måned og dag i måneden er alle inkluderet i datodelen af ​​tidsstemplet. Tidsstemplets tidskomponent inkluderer mindst timen, minutter og sekunder. Millisekunder og tidszonen kan også være inkluderet (offset). Bemærk, at 1 ms =1/1000 s. Derfor bør computeren levere tidsstemplet. Som et resultat skal systemuret være nøjagtigt. java.time er klassen. I dagens Java skal instant bruges til at få tidsstemplet.

java.time.Instant

Java har en klasse kaldet java.time. Øjeblikket blev eksplicit oprettet til tidsstempler. Der er to nødvendige metoder i klassen Instant:now () og toString (). Tidsstempelobjektet returneres af "Nu". Tidsstemplets strengformat er produceret af toString(). Følgende program demonstrerer deres anvendelse:

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant timestamp_object = Instant.now();

String timestamp_string = timestamp_object.toString();

System.out.println(timestamp_string);

}

}

Programmet starter med, at Instant-klassen fra java.time-pakken importeres. Så er der hovedklassens definition (implementering). Den første sætning i main()-metoden kalder Instant-klassens now()-metode. Now() er en statisk metode, hvilket betyder, at den ikke kræver, at det instansierede objekt virker. Det returnerer tidsstempelobjektet for dets Instant-klasse ved at bruge Instant-klassenavnet. Timestamp Instant-objektets toString()-metode returnerer timestamp-objektets læsbare streng i ISO-8601-format. Computeren genererer følgende output på det tidspunkt, hvor den køres:

2022-05-22T11:53:15.271438Z

Dette kræver yderligere forklaring. De første fire cifre repræsenterer begivenhedens år. Den er adskilt fra de følgende to tal, begivenhedens måned, med en bindestreg. Sidstnævnte er adskilt fra de næste to cifre, dagen i måneden for begivenheden, med en bindestreg. Et tidsstempel består af to dele:datoen og klokkeslættet. 'T' adskiller dato- og tidssektionerne. Tidssektionen starter med to cifre (24-timers ur), begivenhedens time. Den er adskilt fra de følgende to cifre, som repræsenterer minutterne for hændelsen, med et kolon.

Det efterfølges af et kolon, som adskiller det fra de følgende to tal, der repræsenterer begivenhedens sekunder. Der er også prikken og mikrosekunderne at overveje. Tidsstemplet har ingen offset, hvis det er Z. Bemærk, at toString() er en dynamisk metode. For at fungere kræver det et initialiseret Instant-objekt. Det giver dig også en streng, som du kan gemme (i en database).

Java's epoke

I Java beregnes tiden ved hjælp af UNIX-epoken. 1970-01-01T00:00:00Z er UNIX-epoken.

Antallet af sekunder siden Java-epoken

Siden Java Epoch beregner følgende applikation antallet af sekunder:

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant timestampObj = Instant.now();

long codeSecs = timestampObj.getEpochSecond();

System.out.println(codeSecs);

}

}

Instant-objektets getEpochSecond()-funktion bruges. Det giver et langt heltal tilbage.

øjeblikkelig minussekunder(lange sekunderFor at trække fra)

Med adskillige sekunder fratrukket, kan den aktuelle dato-tid returneres. Det vil producere en datetime før nu. Det demonstreres i følgende program:

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant instantObject = Instant.now();

Instant codeObject = instantObject.minusSeconds(1000000000);

String codeStr = codeObject.toString();

System.out.println(codeStr);

}

}

Før du trækker antallet af sekunder fra, skal du indsamle det aktuelle tidsstempelobjekt. Følgende er den vigtigste metode, der anvendes:

minusSeconds(long secondsToSubtract)

Det virker kun med umiddelbare objekter, ikke øjeblikkelige klasser (navn).

plusSeconds (long secondsToAdd)

Med flere sekunder tilføjet, kan den aktuelle dato-tid returneres. Derefter har du datetime. Det demonstreres i følgende program:

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant codeInstObject = Instant.now();

Instant codeSbObj = codeInstObject.plusSeconds(1000000);

String codeStr = codeSbObj.toString();

System.out.println(codeStr);

}

}

Du skal hente det aktuelle tidsstempelobjekt, før antallet af sekunder tilføjes. Følgende er den vigtigste metode, der anvendes:

plusSeconds(long secondsToAdd)

Det virker kun med umiddelbare objekter, ikke øjeblikkelige klasser (navn).

Instant Class's statiske egenskaber

EPOCH, MAX og MIN er Instant-klassens statiske attributter (felter). Det instansierede objekt er ikke påkrævet for at få adgang til en statisk egenskab. Det fungerer med klassens navn. EPOCH er,

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant codeInstObject = Instant.EPOCH;

String codeStr = codeInstObject.toString();

System.out.println(codeStr);

}

}

Som forventet er det resulterende output 1970-01-01T00:00:00Z

MAX giver det maksimale understøttede øjeblik. Værdien for MAX udlæses i strengform ved hjælp af følgende program:

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant codeInstantObject = Instant.MAX;

String codeStr = codeInstantObject.toString();

System.out.println(codeStr);

}

}

MIN returnerer det mindste understøttede øjeblik. Værdien for MIN udlæses i strengform ved hjælp af følgende program:

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant codeInstantObject = Instant.MIN;

String codeStr = codeInstantObject.toString();

System.out.println(codeStr);

}

}

Brug af Javas tidsstempelklasse til at få det aktuelle tidsstempel

Timestamp-klassen i Java bruges til at få det aktuelle tidsstempel. Vi fordriver tiden i millisekunder, fordi denne klasse ikke har en standardkonstruktør. Vi bruger System-klassens currentTimeMillis()-metode til at få tiden. Overvej følgende eksempel.

import java.sql.Timestamp;

public class CodeTimestamp {

    public static void main(String[] args) {

        Long date_time = System.currentTimeMillis();
        Timestamp codeTimestamp = new Timestamp(ate_time);
        System.out.println("The Current Time Stamp: "+codeTimestamp);
    }
}

Hent det aktuelle tidsstempel ved hjælp af Javas datoklasse

Vi kan bruge util-pakkens Date-klasse til at erhverve det aktuelle tidsstempel. Klassen SimpleDateFormat bruges til at formatere tidsstemplet i formatet åååå.MM.dd. Overvej følgende eksempel.

import java.text.SimpleDateFormat;
import java.util.Date;

public class CodeSimpleDateFormat{

    public static void main(String[] args) {

        SimpleDateFormat codeDate = new SimpleDateFormat("yyyy.MM.dd.HH:mm:ss");
        String codeTimeStamp = codeDate.format(new Date());
        System.out.println("The Current Time Stamp is: "+codeTimeStamp);
    }
}

Java's bruger ZonedDateTime-klassen til at få det aktuelle tidsstempel

Java datetime-pakkens ZonedDateTime-klasse genererer et tidsstempel med zoneinformation. Vi får systemets standardzone ved hjælp af systemDefault()-funktionen i ZoneId, og vi får det aktuelle tidsstempel med det leverede zoneId ved hjælp af now()-metoden. Efter at have opnået det aktuelle tidsstempel, bruger vi DateTimeFormatter-klassens ofPattern()-funktion til at få tidsstemplet i et bestemt format. Overvej følgende eksempel.

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class CodeZonedDateTime{

    public static void main(String[] args) {

        ZoneId codeZid = ZoneId.systemDefault();
        ZonedDateTime dateTime = ZonedDateTime.now(codeZid);
        System.out.println("The Current Time Stamp is: "+dateTime);

        // formatting into a specific format
        DateTimeFormatter codeFormatter = DateTimeFormatter.ofPattern( "uuuu.MM.dd.HH:mm:ss" );
        String codeTimeStamp = datetime.format(codeFormatter);
        System.out.println("The Current Time Stamp is: "+codeTimeStamp);
    }
}

Javas brug af LocalDateTime-klassen for at få det aktuelle tidsstempel

Ved hjælp af Java 8 kan du erhverve det aktuelle tidsstempel ved at bruge klassen LocalDateTime. Overvej følgende eksempel.

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class CodeLocalDateTime{

    public static void main(String[] args) {

        LocalDateTime codeDateTime = LocalDateTime.now();
        System.out.println("The Current Time Stamp's Default Format is: "+codeDateTime);
        String codeTimeStamp = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(codeDateTime);
        System.out.println("The Current Time Stamp is: "+codeTimeStamp);
    }
}

Javas brug af Instant Class for at få det aktuelle tidsstempel

Det aktuelle tidsstempel kan fås ved hjælp af klassen Instant. For at få det aktuelle tidsstempel på et øjeblik bruger vi funktionen now() i klassen Instant.

import java.time.Instant;

public class CodeInstant{

    public static void main(String[] args) {
        Instant codeTimeStamp = Instant.now();
        System.out.println(" Your Current Default Format Time Stamp is: "+codeTimeStamp);
    }
}

Brug af Javas tidsstempelklasse til at få det aktuelle tidsstempel

Klasserne Timestamp og Instant giver en anden måde at få det aktuelle tidsstempel på i Java. Overvej følgende eksempel.

import java.sql.Timestamp;
import java.time.Instant;

public class CodeTimestamp {

    public static void main(String[] args) {

        long codeTime = System.currentTimeMillis();
        Timestamp codeTimestamp = new Timestamp(codeTime);
        Instant codeInstant = codeTimestamp.toInstant();
        System.out.println("The Current codeInstant Time Stamp is: "+codeInstant);
    }
}

Javas brug af toInstant()-metoden til at få det aktuelle tidsstempel

Yderligere kan vi aktivere toInstant()-metoden i Date-klassen for at erhverve det aktuelle tidsstempel, hvis vi har et datoobjekt, der afspejler tidsstemplet.

import java.time.Instant;
import java.util.Date;

public class CodeToInstant {

    public static void main(String[] args) {

        Date codeDate = new Date();
        Instant codeInstant = codeDate.toInstant();
        System.out.println("The Current codeInstant Time Stamp is: "+codeInstant);
    }
}

Eksempel:Java Get TimeStamp

import java.util.Date;
import java.sql.Timestamp;
 
public class CodeFetchTimeStamp
{
    public static void main( String[] args )
    {
 
 Date newDate= new Date();
 
 long timeNow = newDate.getTime();
     System.out.println("The Time now in Milliseconds: " + timeNow);
 
 Timestamp timestamp = new Timestamp(time);
 System.out.println("The Current Time Stamp is: " + timestamp);
    }
}

Funktionen getTime() bruges i følgende eksempel til at få den aktuelle tid i millisekunder. Tidsstemplet vil derefter konvertere til det korrekte tidspunkt. Følgende eksempel er multi-line. Men hvis du kun ønsker det aktuelle tidsstempel, skal du bruge koden på én linje ovenfor.

Eksempel:Hent kun datoen i Java

For udelukkende at finde datoen og klokkeslættet skal du bruge SimpleDateFormat med klassen Kalender.

import java.util.Calendar;
import java.text.SimpleDateFormat;
 
public class CodeFetchTimeStamp
{
    public static void main( String[] args )
    {
         Calendar newCalendar = Calendar.getInstance();
 
         SimpleDateFormat sDateFormat = new SimpleDateFormat("MM/dd/yyyy");
         System.out.println(sDateFormat .format(newCalendar .getTime()));
    }
}

Eksempel:Hent den aktuelle tid i Java

Du kan også bruge SimpleDateFormat med klassen Kalender til kun at finde tidspunktet.

import java.util.Calendar;
import java.text.SimpleDateFormat;
 
public class CodeFetchTimeStamp
{
    public static void main( String[] args )
    {
         Calendar codeCalendar = Calendar.getInstance();
 
         SimpleDateFormat sDateFormat = new SimpleDateFormat("HH:mm:ss");
         System.out.println(sDateFormat .format(codeCalendar.getTime()));
    }
}

Eksempel:Illustrerer brugen af ​​tidsstempel

// 2022-05-22 16:48:05.591
Timestamp new_timestamp = new Timestamp(System.currentTimeMillis());
System.out.println(new_timestamp)

  // 2022-05-22 16:48:05.591
  Date newDate = new Date();
Timestamp new_timestamp_two = new Timestamp(newDate.getTime());
System.out.println(new_timestamp_two)

  // convertion of an Instant to Timestamp
  Timestamp new_timestamp_three = Timestamp.from(Instant.now())
  System.out.println(new_timestamp_three)

  // convertion of a ZonedDateTime to Instant to Timestamp
  Timestamp new_timestamp_four = Timestamp.from(ZonedDateTime.now().toInstant()));
System.out.println(new_timestamp_four)

  // conversion of a Timestamp to Instant
  Instant instant = new_timestamp_four.toInstant();

Eksempel:Java-tidsstempler

Følgende software bruger java.sql.Timestamp til at hente det aktuelle tidsstempel og SimpleDateFormat til at formatere skærmen.

package com.codeunderscored;

import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Date;

public class CodeTimeStamp {

    // 2021.05.22.16.34.26
    private static final SimpleDateFormat simpleDateFormatOne = new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss");
System.out.println(simpleDateFormatOne)

    // 2021-05-22T16:44:39.083+08:00
    private static final SimpleDateFormat simpleDateFormatTwo = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");

    // 2021-05-22 16:48:05
    private static final SimpleDateFormat simpleDateFormatThree = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) {

        // approach one
        Timestamp codeTimestamp = new Timestamp(System.currentTimeMillis());
        System.out.println(codeTimestamp);                      // 2021-05-22 16:34:26.666

        // approach two - via Date
        Date newDate = new Date();
        System.out.println(new Timestamp(newDate.getTime()));  // 2022-05-22 16:34:26.666
                                                            // The milliseconds count since January 1, 1970, 00:00:00 GMT
        System.out.println(codeTimestamp.getTime());            // 1616574866666

        System.out.println(simpleDateFormatOne.format(timestamp));         // 2022.05.22.16.34.26

        System.out.println(simpleDateFormatTwo.format(timestamp));         // 2022-05-22T16:48:05.591+08:00

        System.out.println(simpleDateFormatThree.format(timestamp));         // 2022-05-22 16:48:05

    }
}

Eksempel:Øjeblikkelig til eller fra tidsstempelkonverteren

Dette eksempel viser, hvordan man bruger den nye Java 8 java.time-klasse. Til og fra det gamle java.sql.Timestamp er øjeblikkeligt.

 // conversion of the Instant to an equivalent Timestamp
  Timestamp codeTimestamp = Timestamp.from(Instant.now())

  // converting a Timestamp to a corresponding Instant
  Instant instant = codeTimestamp.toInstant();

package com.codeunderscored;

import java.sql.Timestamp;
import java.time.Instant;

public class CodeInstant {

  public static void main(String[] args) {

      Timestamp codeTimestamp = new Timestamp(System.currentTimeMillis());
      System.out.println(codeTimestamp);                  // 2022-05-22 17:12:03.311
      System.out.println(codeTimestamp.getTime());        // 1616577123311

      // Converting a Timestamp to an Instant
      Instant newInstant = codeTimestamp.toInstant();
      System.out.println(newInstant);                    // 2022-05-22T09:12:03.311Z
      System.out.println(newInstant.toEpochMilli());     // 1616577123311

      // Conversion of an Instant to a corresponding Timestamp
      Timestamp timestampFromInstant = Timestamp.from(instant);
      System.out.println(timestampFromInstant.getTime());    // 1616577123311
  }
}

Eksempel:Opret en tabel med et tidsstempel

I JDBC-programmering bruges tidsstemplet stadig i vid udstrækning. Overvej følgende konverteringer:

  // Java 8, java.time.*

  // converting a LocalDateTime to respective Timestamp
  preparedStatement.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()));

  // converting an Instant to a Timestamp
  preparedStatement.setTimestamp(1, Timestamp.from(Instant.now()));

  // Converting a ZonedDateTime to a corresponding Instant then to a  Timestamp
  preparedStatement.setTimestamp(3, Timestamp.from(ZonedDateTime.now().toInstant()));


The subsequent SQL example shows how to insert a Timestamp into a table using JDBC.

package com.codeunderscored;

import java.math.BigDecimal;
import java.sql.*;
import java.time.LocalDateTime;

public class CodeJdbc {

  private static final String sql_query = "INSERT into Code_Employee (name, emp_no, date_created) VALUES (?,?,?)";

  public static void main(String[] args) {

      try (Connection codeConnection = DriverManager.getConnection(
              "jdbc:postgresql://127.0.0.1:5432/code", "code", "Underscored");
           PreparedStatement codePrStatement = codeConnection.prepareStatement(sql_query)) {

          codePrStatement.setString(1, "Joy");
          codePrStatement.setBigDecimal(2, new BigDecimal("098"));
          codePrStatement.setTimestamp(3, Timestamp.valueOf(LocalDateTime.now()));

	// other alternatives for the date_created value
          // codePrStatement.setTimestamp(3, Timestamp.from(ZonedDateTime.now().toInstant()));
          // codePrStatement.setTimestamp(3, Timestamp.from(Instant.now()));

          int codeRow = codePrStatement.executeUpdate();

          // The count of rows affected
          System.out.println(codeRow); //1

      } catch (SQLException e) {
          System.err.format("SQL State: %s\n%s", e.getSQLState(), e.getMessage());
      } catch (Exception e) {
          e.printStackTrace();
      }

  }
}

Eksempel:Sådan får du det aktuelle tidsstempel i java

import java.sql.Timestamp;
import java.util.Date;

public class CodeTimeStamp
{
    public static void main( String[] args )
    {
         // Creating a Date object
	 Date codeDate= new Date();

         //getTime() returns current time in milliseconds
	 long codeTime = codeDate.getTime();

         // the count milliseconds is passed to constructor of Timestamp class
	 Timestamp codeTimestamp = new Timestamp(time);
	 System.out.println("The Current Time Stamp is: "+codeTimestamp);
    }
}

De handlinger, vi foretog i eksemplet ovenfor, er som følger:

1) Oprettet et Dato-klasseobjekt.

2) Ved at bruge metoden getTime() fra Date, opnåede vi den aktuelle tid i millisekunder.

3) Oprettede et Timtestamp-klasseobjekt og leverede millisekunderne opnået i trin 2 til klassens konstruktør under objektkonstruktionen. Sidstnævnte opretter tidsstemplet ud fra den angivne millisekundværdi.

Konklusion

Denne lektion har vist dig, hvordan du henter det aktuelle tidsstempel i Java og indeholder noget eksempelkode, der hjælper dig med at forstå konceptet. Timestamp-klassen, Date-klassen, ZonedDateTime-klassen, LocalDateTime-klassen og andre Java-klasser kan alle bruges til at få det aktuelle tidsstempel.

Tidsstemplet repræsenterer datoen og klokkeslættet for en hændelse. Nus tidsstempel er det aktuelle tidsstempel. Java-pakkens Instant-klasse, java.time.*, bør bruges til tidsstempelarbejde. Bemærk også, at tidsstempelklassen har to vigtige metoder:now() og toString ().