Resumo da representação de data e hora do Java 17

Enterprise 2023-05-17 15:39:44 views: null

Resumo da representação de data e hora do Java 17

Introdução

Como várias outras linguagens de programação, Java também possui muitas formas para representar data e hora.Além da string mais básica, existem classes e pacotes mais poderosos que podem realizar transformações flexíveis de data e hora. Por Java SE 17exemplo, as aulas relacionadas mais práticas são:

java.time

java.time.Clock (abstract)
java.time.LocalDateTime (final)
java.time.Instant (final)

java.util

java.util.Calendar (abstract)
java.util.Date

java.sql

java.sql.Date
java.sql.Time

java.time.Clock

Como uma classe abstrata, Clock tem relativamente poucas funções de método, usadas principalmente para obter a hora atual, e pode Durationser usada em combinação com classes, etc. Os métodos comumente usados ​​são

static Clock systemDefaultZone();
static Clock systemUTC();
static Clock tick(Clock baseClock, Duration tickDuration);

A obtenção de um objeto Clock geralmente requer um fuso horário, que só pode ser um objeto da classe ZoneId, que pode ser obtido através do método estático ou método de construção de ZoneId. O método instantâneo geralmente é usado para obter o tempo padrão ISO-8601 durante a saída. Se você precisar determinar o fuso horário, deverá usar instant().atZone(clock.getZone())o fuso horário de saída no final

Clock.systemDefaultZone

systemDefaultZoneOu seja, retorne a hora atual no fuso horário padrão e o fuso horário padrão será exibido após a saída, como

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        System.out.println(Clock.systemDefaultZone);
        System.out.println(clock.instant().atZone(clock.getZone()));
    }
}

saída

SystemClock[Asia/Shanghai]
2022-07-02T19:04:13.769546900+08:00[Asia/Shanghai]

Este método estático define o ZoneId padrão, e o ZoneId padrão também pode ser passado ZoneId.of("Asia/Shanghai")ou ZoneId.systemDefault()obtido, e getZone()o fuso horário do objeto Clock também pode ser gerado por meio do método.

Relógio.sistemaUTC

systemUTCO método systemDefaultZoneé basicamente o mesmo que o método, exceto que o fuso horário correspondente é definido como o fuso horário UTC e instant().atZone(clock.getZone())o fuso horário ainda é Z ao usar a saída do método

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        System.out.println(Clock.systemUTC);
        System.out.println(clock.instant().atZone(clock.getZone()));
    }
}

saída

SystemClock[Z]
2022-07-02T11:04:13.769546900Z

Clock.tick

Este método precisa ser combinado com a classe Duration para representar a duração.O método tick retornará o objeto Clock mais próximo do intervalo de tempo especificado, e uma série de tempos de diferença iguais pode ser obtida.

Ele pode ser usado como uma função de arredondamento ao cronometrar, como usar o método Duration.ofSeconds()ou Clock.tickSeconds()para obter o objeto Clock de todo o segundo

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Clock clock = Clock.systemDefaultZone();
        Thread.sleep(990);
        System.out.println(Clock.tick(clock, Duration.ofSeconds(1)).instant().atZone(clock.getZone()));
        Thread.sleep(990);
        System.out.println(Clock.tick(clock, Duration.ofSeconds(1)).instant().atZone(clock.getZone()));
        Thread.sleep(990);
        System.out.println(Clock.tick(clock, Duration.ofSeconds(1)).instant().atZone(clock.getZone()));
    }
}

saída

2022-07-02T19:27:55+08:00[Asia/Shanghai]
2022-07-02T19:27:56+08:00[Asia/Shanghai]
2022-07-02T19:27:57+08:00[Asia/Shanghai]

java.time.LocalDateTime

LocalDateTime pode ser considerado a forma mais prática de representação de data e hora. É equivalente a combinar LocalDate e LocalTime e salvar data e hora ao mesmo tempo. Ele pode não apenas obter e calcular o ano, mês, dia, hora, minuto e segundo, mas também converter entre LocalDate ou LocalTime.Ao produzir, você também pode personalizar o formato por meio de format()ee outros métodos para obter as mesmas funções ou funções ainda mais flexíveis que outras classes. DateTimeFormatter.ofPattern()Os principais métodos incluem:

int compareTo(ChronoLocalDateTime<?> other);
String format(DateTimeFormatter formatter);
LocalDateTime (minus/plus)(Days/Hours/Minutes/Months...)(long days/hours/minutes/months...);
static LocalDateTime now();
static LocalDateTime of(...);
static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter);

localDateTime.compareTo

Comparando dois objetos LocalDateTime diretamente, o valor de retorno é adequado para comparação numérica geral. A aplicação mais comum é classificar os objetos em ArrayList de acordo com a sequência de tempo. Você pode implementar a interface Comparator ou usar a função lambda para obter a comparação de classificação. Mais prático do que outros métodos da classe isBefore, isAfter, etc.isEqual

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        ArrayList<LocalDateTime> localDateTimes = new ArrayList<>();
        for(int i=0;i<10;i++) {
    
    
            localDateTimes.add(LocalDateTime.now());
            Thread.sleep(1000);
        }
        localDateTimes.sort(LocalDateTime::compareTo);
        for(LocalDateTime localDateTime:localDateTimes)
            System.out.println(localDateTime);
    }
}

saída

2022-07-03T09:49:46.140729100
2022-07-03T09:49:47.143319400
2022-07-03T09:49:48.155282200
2022-07-03T09:49:49.166319900
2022-07-03T09:49:50.181316500
2022-07-03T09:49:51.182851900
2022-07-03T09:49:52.185095100
2022-07-03T09:49:53.196120600
2022-07-03T09:49:54.197270600
2022-07-03T09:49:55.210269400

localDateTime.format

Este método é principalmente para a saída formatada do objeto, geralmente DateTimeFormatter.ofPattern()usado junto com o método, o ano, mês, dia, hora, minuto e segundo são representados por yy, MM, dd, HH, mm, respectivamente ss, e podem gerar permutações e combinações em diferentes formatos

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now.format(DateTimeFormatter.ofPattern("yyyy.MM.dd --- HH:mm:ss")));
        System.out.println(now.format(DateTimeFormatter.ofPattern("yy-MM-dd HH--mm--ss")));
        System.out.println(now.format(DateTimeFormatter.ofPattern("yyyy MM dd")));
        System.out.println(now.format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        System.out.println(now.format(DateTimeFormatter.ofPattern("(yyyy) HH ss----MMmm")));
    }
}

saída

2022.07.03 --- 09:52:17
22-07-03 09--52--17
2022 07 03
09:52:17
(2022) 09 17----0752

localDateTime.plusDays…

Este método pode adicionar e subtrair objetos LocalDateTime arbitrariamente, podendo ser expresso em qualquer unidade, o que é muito prático na hora de definir deadlines ou limites de tempo

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);
        System.out.println(localDateTime.plusHours(10));
        System.out.println(localDateTime.minusDays(34));
        System.out.println(localDateTime.plusWeeks(4));
        System.out.println(localDateTime.minusYears(5));
    }
}

saída

2022-07-03T00:24:34.840940900
2022-07-03T10:24:34.840940900
2022-05-30T00:24:34.840940900
2022-07-31T00:24:34.840940900
2017-07-03T00:24:34.840940900

LocalDateTime.now

Obtenha a hora atual diretamente, armazene mais informações do que objetos Date comuns, objetos LocalDate, etc., e o fuso horário é o fuso horário padrão do sistema

LocalDateTime.of

Este método retorna o objeto LocalDateTime correspondente ao ano, mês, dia, hora, minuto e segundo definidos, incluindo várias sobrecargas. Você pode definir todas as unidades de nanossegundos a anos ou pode usar objetos LocalDate e LocalTime diretamente para emenda. além do método LocalDateTime.now(), Este método é um método relativamente conveniente para obter um objeto de instância.

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        System.out.println(LocalDateTime.of(2022, 7, 3, 6, 6));
        System.out.println(LocalDateTime.of(2022, 7, 3, 6, 6, 6));
        System.out.println(LocalDateTime.of(2022, 7, 3, 6, 6, 6, 666666666));
    }
}

saída

2022-07-03T06:06
2022-07-03T06:06:06
2022-07-03T06:06:06.666666666

LocalDateTime.parse

Este método é semelhante ao método format, ambos podem ser usados ​​para a conversão entre LocalDateTime e String, e a variável de formato do parâmetro principal também é usada para DateTimeFormatter.ofPattern()personalizar o formato

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
        String YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";
        String YY_MM_DD_HH_MM_SS = "yy-MM-dd HH:mm:ss";
        System.out.println(LocalDateTime.parse("20220606060606", DateTimeFormatter.ofPattern(YYYYMMDDHHMMSS)));
        System.out.println(LocalDateTime.parse("20220606060606666", DateTimeFormatter.ofPattern(YYYYMMDDHHMMSSSSS)));
        System.out.println(LocalDateTime.parse("22-06-06 06:06:06", DateTimeFormatter.ofPattern(YY_MM_DD_HH_MM_SS)));
    }
}

saída

2022-06-06T06:06:06
2022-06-06T06:06:06.666
2022-06-06T06:06:06

java.util.Instant

A classe Instant representa um determinado tempo, com precisão de nanossegundos, e geralmente é usada em combinação com outras classes. As classes LocalDateTime, LocalDate, LocalTime e Calendar podem ser convertidas em classes Instant usando o método toInstant. Na verdade, o método da classe Instant é muito semelhante ao LocalDateTime, mas não contém o parâmetro de fuso horário. A classe Instant representa a escala de tempo de Java e pode ser usada comumente em outras classes. Os principais métodos incluem:

int compareTo(Instant otherInstant);
static Instant now();
static Instant parse(CharSequence text);
Instant (minus/plus)(Seconds/Millis/Nanos)(long amount);

instant.compareTo

É exatamente igual ao método compareTo de outras classes e pode ser usado para comparar a sequência de tempo ao classificar

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Instant instant = Instant.now();
        Instant now = instant;
        Instant before = instant.minusSeconds(30);
        Instant after = instant.plusSeconds(25);
        System.out.println(instant.compareTo(before));
        System.out.println(instant.compareTo(after));
        System.out.println(instant.compareTo(now));
    }
}

saída

1
-1
0

Instant.agora

Este método pode obter a hora atual ou você pode passar os parâmetros da classe Clock e usar este parâmetro para obter a hora atual

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Instant instant = Instant.now(Clock.systemDefaultZone());
        Instant now = Instant.now();
        System.out.println(instant);
        System.out.println(now);
    }
}

saída

2022-07-03T01:58:34.374565500Z
2022-07-03T01:58:34.374565500Z

Instant.parse

O método parse da classe Instant só pode obter o parâmetro time no formato de hora UTC. Como a classe Instant não contém um fuso horário, OffsetDateTime atOffset(ZoneOffset offset)métodos e ZonedDateTime atZone(ZoneId zone)métodos são frequentemente usados ​​para saída

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Instant instant = Instant.parse("2022-07-03T01:58:34.374565500Z");
        System.out.println(instant);
        System.out.println(instant.atZone(ZoneId.systemDefault()));
        System.out.println(instant.atOffset(ZoneOffset.ofHours(8)));
    }
}

saída

2022-07-03T01:58:34.374565500Z
2022-07-03T09:58:34.374565500+08:00[Asia/Shanghai]
2022-07-03T09:58:34.374565500+08:00

instant.minus/plusSeconds/Millis/Nanos

A classe Instant também pode obter novas instâncias Instant por meio de cálculos de adição e subtração, mas a classe Instant só pode calcular segundos, milissegundos e nanossegundos. Se você precisar calcular em unidades de ano, mês e dia, precisará escrever uma expressão

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Instant instant = Instant.now();
        System.out.println(instant);
        System.out.println(instant.plusSeconds(30));
        System.out.println(instant.minusMillis(20000));
        System.out.println(instant.minusNanos(439095934904654L));
        System.out.println(instant.plusSeconds(60*60*24*7));
        System.out.println(instant.minusSeconds(60*60*24*30*6));
        System.out.println(instant.plusSeconds(60*60*24*365*20));
    }
}

saída

2022-07-03T02:10:16.235732300Z
2022-07-03T02:10:46.235732300Z
2022-07-03T02:09:56.235732300Z
2022-06-28T00:12:00.300827646Z
2022-07-10T02:10:16.235732300Z
2022-01-04T02:10:16.235732300Z
2042-06-28T02:10:16.235732300Z

java.util.Calendar

A classe Calendar é praticamente igual à classe LocalDateTime e tem funções semelhantes. As constantes de tempo que ele define são bem detalhadas, incluindo constantes que indicam o formato de data e hora e o dia da semana, e os valores int representados para cada mês e cada dia da semana. Os métodos comumente usados ​​correspondem basicamente ao LocalDateTime aula um a um. No entanto, se você precisar formatar a saída, precisará usar String.format()métodos e usar símbolos de formato mais complexos, o que não é conciso o suficiente em comparação com a classe LocalDateTime.

int compareTo(Calendar anotherCalendar);
static Calendar getInstance();
void set(int year, int month, int date...);

calendar.compareTo

Igual ao método compareTo de LocalDateTime, pode ser usado para classificação

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Calendar calendar = Calendar.getInstance();
        Calendar now = calendar;
        Calendar after = Calendar.getInstance();
        Calendar before = Calendar.getInstance();
        after.roll(Calendar.DATE, true);
        before.roll(Calendar.DATE, false);
        System.out.println(calendar.compareTo(now));
        System.out.println(calendar.compareTo(after));
        System.out.println(calendar.compareTo(before));
    }
}

saída

0
-1
1

Calendar.getInstance

Igual ao método now de LocalDateTime, ele pode obter a hora atual e, em seguida, exibir a hora UTC com o método toInstant. Se você precisar formatar a saída, precisará de String.format()um System.out.printfmétodo

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Calendar calendar = Calendar.getInstance();
        System.out.printf("%1$ty-%1$tm-%1$td%n", calendar);
        System.out.printf("%1$tY-%1$tB-%1$td%n", calendar);
        System.out.printf("%1$tD%n", calendar);
        System.out.printf("%1$tF%n", calendar);
        System.out.printf("%1$tH:%1$tM:%1$tS%n", calendar);
        System.out.printf("%1$tH:%1$tM:%1$tS %1$tL%n", calendar);
        System.out.printf("%1$tH:%1$tM:%1$tS %1$tL %1$tp%n", calendar);
        System.out.printf("%1$tR%n", calendar);
        System.out.printf("%1$tT%n", calendar);
        System.out.printf("%1$tr%n", calendar);
        System.out.printf("%1$tF %1$tA%n", calendar);
        System.out.printf("%1$tF %1$ta%n", calendar);
        System.out.printf("%1$tc%n", calendar);
    }
}

saída

22-07-03
2022-七月-03
07/03/22
2022-07-03
10:35:39
10:35:39 405
10:35:39 405 上午
10:35
10:35:39
10:35:39 上午
2022-07-03 星期日
2022-07-03 周日
周日 7月 03 10:35:39 CST 2022

calendar.set

Semelhante aos métodos withYear/withMonth/withDayOfMonth... de LocalDateTime, a unidade de tempo específica do objeto pode ser definida e as unidades de segundos a anos podem ser modificadas.

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.toInstant());
        calendar.set(2020, Calendar.JULY, 6);
        System.out.println(calendar.toInstant());
        calendar.set(2021, Calendar.AUGUST, 6, 6, 6);
        System.out.println(calendar.toInstant());
        calendar.set(2022, Calendar.SEPTEMBER, 6, 6, 6, 6);
        System.out.println(calendar.toInstant());
    }
}

saída

2022-07-02T17:17:10.696Z
2020-07-05T17:17:10.696Z
2021-08-05T22:06:10.696Z
2022-09-05T22:06:06.696Z

java.util.Date

A classe Date é um tipo de hora relativamente simples em java. Ela pode cooperar com a classe SimpleDateFormat para produzir um formato específico. A classe Date pode usar diretamente o método de construção para simplesmente obter o objeto Date. Você pode chamar o método de construção em milissegundos ou obter diretamente a hora atual. A maioria dos métodos é igual a Calendar. Ou a classe LocalDateTime coincide e alguns dos métodos também são substituídos pela classe Calendar. Atualmente, apenas os milissegundos podem ser usados ​​para representar a hora, e o a saída é formatada.

Construtor Date()/Date(data longa)

O método Date() pode instanciar um objeto Date para obter a hora atual. O parâmetro do método Date(long date) é o número de milissegundos a partir de 1º de janeiro de 1970, que pode obter a hora com precisão

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(6666666666666L)));
    }
}

saída

2022-07-03 01:31:27
2181-04-04 19:51:06

Saída formatada simpleDateFormat.format

A classe SimpleDateFormat pode fornecer o método format para formatar o objeto Date em uma String, aproximadamente DateTimeFormatter.ofPattern()igual ao método, usando yy, MM, dd, HH, para representar a horammss

Saída formatada System.out.printf

No método System.out.printf, você pode usar especificadores de formato para gerar saída de objetos Date para obter uma saída personalizada de ano, mês, dia, hora, minuto e segundo. Os especificadores de formato incluem

%ty/%ty %tm %td %tB/%tb %tH/%tI %tM %tS %tL %tp %tA/%ta %tc
anos mês data nome do mês Hora minuto Segundo milissegundo manhã tarde Dia da semana todas as informações 
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Date date = new Date();
        System.out.printf("%1$ty-%1$tm-%1$td%n", date);
        System.out.printf("%1$tY-%1$tB-%1$td%n", date);
        System.out.printf("%1$tD%n", date);
        System.out.printf("%1$tF%n", date);
        System.out.printf("%1$tH:%1$tM:%1$tS%n", date);
        System.out.printf("%1$tH:%1$tM:%1$tS %1$tL%n", date);
        System.out.printf("%1$tH:%1$tM:%1$tS %1$tL %1$tp%n", date);
        System.out.printf("%1$tR%n", date);
        System.out.printf("%1$tT%n", date);
        System.out.printf("%1$tr%n", date);
        System.out.printf("%1$tF %1$tA%n", date);
        System.out.printf("%1$tF %1$ta%n", date);
        System.out.printf("%1$tc%n", date);
    }
}

saída

22-07-03
2022-七月-03
07/03/22
2022-07-03
02:04:16
02:04:16 798
02:04:16 798 上午
02:04
02:04:16
02:04:16 上午
2022-07-03 星期日
2022-07-03 周日
周日 7月 03 02:04:16 CST 2022

java.sql.Data

Esta classe é java.util.Dateuma subclasse da classe, que é usada principalmente para JDBC para reconhecer objetos de formato Data SQL em operações de banco de dados. Por exemplo, para objetos PreparedStatement contendo instruções SQL ou objetos ResultSet obtidos pela execução de instruções SQL de consulta, você pode usar métodos para definir parâmetros da variável setDate()e getDate()Método para obter o objeto Date no resultado da consulta ao banco de dados, tomando como exemplo o MySQL 8.0, mysql-connector-java-8.0.29:

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        String queryStr = "SELECT * FROM dates WHERE date = ?";
        PreparedStatement ps = null;
        ResultSet result = null;
        try {
    
    
            ps.setDate(1, new Date(6666666));
            result = ps.executeQuery();
            while(result.next())
                System.out.println(result.getDate(1).toInstant);
        } catch (SQLException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            try {
    
    
                if(ps != null)
                    ps.close();
            } catch(SQLException e) {
    
    
                e.printStackTrace();
            }
            try {
    
    
                if(result != null) 
                    result.close();
            } catch(SQLException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

java.sql.Time

Esta classe é java.util.Dateuma subclasse da classe, que é usada principalmente para JDBC para identificar objetos de formato SQL Time em operações de banco de dados. Você pode usar setTime()métodos para definir parâmetros variáveis ​​e getTime()métodos para obter objetos Time em resultados de consulta de banco de dados. MySQL 8.0, mysql-connector -java -8.0.29 como exemplo:

import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;

public class Test {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        String queryStr = "SELECT * FROM times WHERE time = ?";
        PreparedStatement ps = null;
        ResultSet result = null;
        try {
    
    
            ps.setDate(1, new Time(6666666));
            result = ps.executeQuery();
            while(result.next())
                System.out.println(result.getTime(1).toInstant);
        } catch (SQLException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            try {
    
    
                if(ps != null)
                    ps.close();
            } catch(SQLException e) {
    
    
                e.printStackTrace();
            }
            try {
    
    
                if(result != null) 
                    result.close();
            } catch(SQLException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

Resumir

Pessoalmente, LocalDateTime é uma das classes mais usadas e mais funcionais em todas as formas de tempo. Desde que o Java 8 se juntou a LocalDateTime, ele pode substituir quase completamente as classes Date e Calendar. Para programas Java gerais que envolvem tempo, o uso de LocalDateTime já é completamente suficiente , e suas funções podem abranger quase todas as operações de tempo, então eu pessoalmente recomendo usar essa classe e suas funções quando a representação de tempo for necessária.

referências

https://docs.oracle.com/en/java/javase/17/docs/api/index.html

https://docs.oracle.com/en/java/javase/11/docs/api/index.html

https://docs.oracle.com/javase/8/docs/api/index.html

https://www.runoob.com/java/java-date-time.html

Supongo que te gusta

Origin blog.csdn.net/qq_39033469/article/details/128602289
Recomendado
Clasificación
Diario
Más
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)

Code World

© 2018 codetd.com