O pacote java.util fornece a classe Date para encapsular a data e hora atuais. A classe Date fornece dois construtores para instanciar objetos Date.
O primeiro construtor inicializa o objeto com a data e hora atuais.
Data( )
O segundo construtor recebe um parâmetro, que é o número de milissegundos desde 1º de janeiro de 1970.
Data (milissegundos longos)
Depois que o objeto Date for criado, você poderá chamar os métodos a seguir.
número de série | Métodos e Descrição |
---|---|
1 | boolean after(Date date) retorna verdadeiro se o objeto Date que chama este método for posterior à data especificada, caso contrário, retorna falso. |
2 | boolean before(Date date) retorna verdadeiro se o objeto Date que chama este método for anterior à data especificada, caso contrário, retorna falso. |
3 | Object clone() retorna uma cópia deste objeto. |
4 | int compareTo(Date date) compara o objeto Date quando este método é chamado com a data especificada. Quando os dois são iguais, 0 é retornado. Se o objeto de chamada for anterior à data especificada, um número negativo será retornado. O objeto chamador retorna um número positivo após a data especificada. |
5 | int compareTo(Object obj) Se obj for do tipo Date, a operação será equivalente a compareTo(Date). Caso contrário, lança ClassCastException. |
6 | boolean equals(Data do objeto) retorna verdadeiro quando o objeto Date que chama este método é igual à data especificada, caso contrário, retorna falso. |
7 | long getTime() retorna o número de milissegundos representados por este objeto Date desde 1º de janeiro de 1970 00:00:00 GMT. |
8 | int hashCode() retorna o valor do código hash deste objeto. |
9 | void setTime(long time) define a hora e a data usando o número de milissegundos desde 1º de janeiro de 1970 00:00:00 GMT. |
10 | String toString() converte um objeto Date em uma representação String e retorna a string. |
Obter a data e hora atuais em Java é muito simples. Use o método toString() do objeto Date para imprimir a data e hora atuais, conforme mostrado abaixo:
importar java.util.Date;
classe pública Principal{
public static void main(String args[]) {
//Inicializa o objeto Date Date date = new Date();
//Use a função toString() para exibir data e hora System.out.println(date.toString());
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
Segunda-feira, 04 de maio 09:51:52 CDT 2013
Java usa os três métodos a seguir para comparar duas datas:
Use o método getTime() para obter duas datas (o número de milissegundos desde 1º de janeiro de 1970) e compare os dois valores.
Use os métodos before(), after() e equals(). Por exemplo, se o dia 12 de um mês for anterior ao dia 18, new Date(99, 2, 12).before(new Date (99, 2, 18)) retornará verdadeiro.
Use o método compareTo(), que é definido pela interface Comparable, e a classe Date implementa essa interface.
SimpleDateFormat é uma classe para formatar e analisar datas de maneira sensível à localidade. SimpleDateFormat permite que você escolha qualquer formato de data e hora definido pelo usuário para execução. Por exemplo:
importar java.util.*;
importar java.texto.*;
classe pública Principal{
public static void main(String args[]) {
Data dAgora = nova Data();
SimpleDateFormat pés =
novo SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
System.out.println("Data Atual: " + ft.format(dNow));
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
Data atual: domingo, 18/07/2004 às 16:14:09 PDT
A sequência de padrão de hora é usada para especificar o formato de hora. Neste modo, todas as letras ASCII são reservadas como letras padrão, definidas da seguinte forma:
carta | descrever | Exemplo |
---|---|---|
G | Marca de época | ANÚNCIO |
sim | ano de quatro dígitos | 2001 |
M | mês | Julho ou 07 |
d | data do mês | 10 |
h | Formato AM/PM (1~12) horas | 12 |
H | Hora do dia (0~23) | vinte e dois |
eu | minutos | 30 |
é | segundos | 55 |
S | milissegundos | 234 |
E | dia da semana | Terça-feira |
D | dias do ano | 360 |
F | Dia da semana do mês | 2 (segunda quarta-feira de julho) |
c | semana do ano | 40 |
C | Semana do mês | 1 |
um | Marca AM/PM | PM |
k | Hora do dia (1~24) | vinte e quatro |
K | Formato AM/PM (0~11) hora | 10 |
z | fuso horário | Horário Padrão do Leste |
' | delimitador de texto | Delimitador |
" | citação única | ` |
O método printf facilita a formatação de horas e datas. Use o formato de duas letras, que começa com t e termina com uma letra da tabela abaixo. Por exemplo:
importar java.util.Date;
classe pública Principal{
public static void main(String args[]) {
//Inicializa o objeto Date Date date = new Date();
// Use toString() para exibir data e hora String str = String.format("Data/Hora Atual: %tc", date );
System.out.printf(str);
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
Data/hora atual: sábado, 15 de dezembro, 16:37:57 MST de 2012
Se você precisar fornecer uma data repetidamente, formatar cada parte dessa maneira será um pouco complicado. Portanto, uma string de formato pode ser usada para indicar o índice do parâmetro a ser formatado.
O índice deve seguir imediatamente % e deve terminar com $. Por exemplo:
importar java.util.Date;
classe pública Principal{
public static void main(String args[]) {
//Inicializa o objeto Date Date date = new Date();
// Use toString() para exibir data e hora System.out.printf("%1$s %2$tB %2$td, %2$tY",
"Data de vencimento:", data);
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
Data de vencimento: 09 de fevereiro de 2004
Alternativamente, você pode usar o sinalizador <. Indica que parâmetros previamente formatados devem ser usados novamente. Por exemplo:
importar java.util.Date;
classe pública Principal{
public static void main(String args[]) {
//Inicializa o objeto Date Date date = new Date();
// Exibe o tempo de formatação System.out.printf("%s %tB %<te, %<tY",
"Data de vencimento:", data);
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
Data de vencimento: 09 de fevereiro de 2004
personagem | descrever | exemplo |
c | Data e hora completa | Seg, 04 de maio 09:51:52 CDT 2009 |
F | Data do formato ISO 8601 | 09/02/2004 |
D | Data no formato dos EUA (mês/dia/ano) | 02/09/2004 |
T | 24 horas | 18:05:19 |
R | 12 horas | 18:05:19 |
R | Horário de 24 horas, excluindo segundos | 18:05 |
S | Ano de 4 dígitos (incluindo 0 inicial) | 2004 |
sim | Últimos 2 dígitos do ano (incluindo o 0 inicial) | 04 |
C | Os primeiros 2 dígitos do ano (incluindo o 0 inicial) | 20 |
B | nome completo do mês | Fevereiro |
b | abreviatura do mês | fevereiro |
n | Mês de 2 dígitos (incluindo 0 inicial) | 02 |
d | Data de 2 dígitos (incluindo 0 inicial) | 03 |
e | Data de 2 dígitos (excluindo 0 inicial) | 9 |
UM | Nome completo da semana | Segunda-feira |
um | abreviatura da semana | seg |
j | Ano de 3 dígitos (incluindo 0 inicial) | 069 |
H | Hora de 2 dígitos (incluindo 0 inicial), 00 a 23 | 18 |
k | Hora com 2 dígitos (sem incluir o 0 inicial), 0 a 23 | 18 |
EU | Hora de 2 dígitos (incluindo 0 inicial), 01 a 12 | 06 |
eu | Hora de 2 dígitos (excluindo 0 inicial), 1 a 12 | 6 |
M | Minuto de 2 dígitos (incluindo 0 inicial) | 05 |
S | Segundos de 2 dígitos (incluindo zeros à esquerda) | 19 |
eu | 3 dígitos de milissegundos (incluindo 0s iniciais) | 047 |
N | Nanossegundos de 9 bits (incluindo 0 inicial) | 047000000 |
P | sinal maiúsculo da tarde | PM |
p | Sinal da tarde em letras minúsculas | tarde |
z | Deslocamento digital RFC 822 do GMT | -0800 |
Z | fuso horário | PST |
é | Número de segundos desde 01-01-1970 00:00:00 GMT | 1078884319 |
P | Desde 01-01-1970 00:00:00 GMT | 1078884319047 |
Existem outras classes úteis relacionadas a data e hora. Para obter mais detalhes, você pode consultar a documentação dos padrões Java.
A classe SimpleDateFormat possui alguns métodos adicionais, notadamente parse(), que tenta analisar uma string de acordo com o armazenamento formatado de um determinado objeto SimpleDateFormat. Por exemplo:
importar java.util.*;
importar java.texto.*;
classe pública Principal{
public static void main(String args[]) {
SimpleDateFormat ft = new SimpleDateFormat ("aaaa-MM-dd");
String entrada = args.length == 0? "1818-11-11": args[0];
System.out.print(input + "Analisa como");
Data t;
tentar {
t = pés.parse(entrada);
System.out.println(t);
} catch (ParseException e) {
System.out.println("Não analisável usando " + ft);
}
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
$javaDateDemonstração
11/11/1818 analisa como quarta-feira, 11 de novembro, 00:00:00 GMT 1818
$ java DateDemo 01/12/2007
01/12/2007 é analisado como sábado, 01 de dezembro, 00:00:00 GMT de 2007
Sono Java(sono)
Você pode colocar um programa em suspensão por um milissegundo ou enquanto o computador durar. Por exemplo, o seguinte programa dorme por 3 segundos:
importar java.util.*;
classe pública Principal{
public static void main(String args[]) {
tentar {
System.out.println(nova Data() + "n");
Thread.sleep(5*60*10);
System.out.println(nova Data() + "n");
} catch (Exceção e) {
System.out.println("Obtive uma exceção!");
}
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
Domingo, 3 de maio, 18:04:41 GMT de 2009
Domingo, 3 de maio, 18:04:44 GMT de 2009
Um exemplo abaixo mostra como medir um intervalo de tempo em milissegundos:
importar java.util.*;
classe pública Principal{
public static void main(String args[]) {
tentar {
início longo = System.currentTimeMillis();
System.out.println(nova Data() + "n");
Thread.sleep(5*60*10);
System.out.println(nova Data() + "n");
final longo = System.currentTimeMillis();
diferença longa = fim - início;
System.out.println("A diferença é: " + diff);
} catch (Exceção e) {
System.out.println("Obtive uma exceção!");
}
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
Domingo, 3 de maio, 18:16:51 GMT de 2009
Domingo, 3 de maio, 18:16:54 GMT de 2009
A diferença é: 3050
Agora podemos formatar e criar um objeto de data, mas como podemos definir e obter partes específicas dos dados de data, como hora, dia ou minuto, e como podemos adicionar ou subtrair valores dessas partes da data? ?O quê? A resposta é usar a classe Calendar.
A classe Calendar é muito mais poderosa que a classe Date e sua implementação também é mais complexa que a classe Date.
A classe Calendar é uma classe abstrata que implementa objetos de subclasses específicas em uso real. O processo de criação de objetos é transparente para os programadores e só precisa ser criado usando o método getInstance.
Calendar c = Calendar.getInstance();//O padrão é a data atual
Para usar a classe Calendar para representar um horário específico, você precisa primeiro criar um objeto Calendar e, em seguida, definir os parâmetros ano, mês e dia no objeto para concluir.
//Cria um objeto Calendário representando o Calendário de 12 de junho de 2009 c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
Essas constantes são usadas na classe Calendar para representar significados diferentes. Muitas classes no jdk realmente adotam essa ideia.
constante | descrever |
---|---|
Calendário.ANO | anos |
Calendário.MÊS | mês |
Calendário.DATE | data |
Calendário.DAY_OF_MONTH | A data tem exatamente o mesmo significado que o campo acima |
Calendário.HORA | hora no relógio de 12 horas |
Calendário.HOUR_OF_DAY | hora em 24 horas |
Calendário.MINUTE | minuto |
Calendário.SEGUNDO | Segundo |
Calendário.DAY_OF_WEEK | dia da semana |
Definir configurações
como:
Calendário c1 = Calendar.getInstance();
Chamar:
conjunto de void final público (int ano,int mês,int data)
c1.set(2009, 6 - 1, 12);//Define o ano, mês e dia do objeto Calendário c1 como: 2009, 5, 12
Usar configurações de tipo de campo
Se você definir apenas o valor de um determinado campo, como data, poderá usar o seguinte método de definição:
conjunto de vazios públicos (campo int, valor int)
Defina a data representada pelo objeto c1 para o dia 10 e todos os outros valores serão recalculados
c1.set(Calendário.DATA,10);
Defina o ano representado pelo objeto c1 como 2008 e todos os outros valores serão recalculados
c1.set(Calendário.ANO,2008);
O significado de outro conjunto de atributos de campo pode ser deduzido por analogia.
Adicionar configurações
Calendário c1 = Calendar.getInstance();
Adicione 10 à data do objeto c1, que é a data 10 dias após a data representada por c1. Todos os outros valores serão recalculados.
c1.add(Calendário.DATA, 10);
Subtraia 10 da data do objeto c1, que é a data 10 dias anterior à data representada por c1. Todos os outros valores serão recalculados.
c1.add(Calendário.DATA, -10);
O significado de add para outros atributos de campo pode ser deduzido por analogia.
Calendário c1 = Calendar.getInstance();
// Obtém o ano int year = c1.get(Calendar.YEAR);
// Obtém o mês int mês = c1.get(Calendar.MONTH) + 1;
// Obtém a data int date = c1.get(Calendar.DATE);
// Obtém a hora int hour = c1.get(Calendar.HOUR_OF_DAY);
// Obtém o minuto int minuto = c1.get(Calendar.MINUTE);
// Obtém o segundo int second = c1.get(Calendar.SECOND);
// Obtém o dia da semana (nota (isso é diferente da classe Date): 1 representa domingo, 2 representa a semana 1, 3 representa terça-feira e assim por diante)
int dia = c1.get(Calendário.DAY_OF_WEEK);
A classe Calendar implementa o calendário Gregoriano e GregorianCalendar é uma implementação específica da classe Calendar.
O método getInstance() do Calendar retorna um objeto GregorianCalendar inicializado por padrão com a localidade e fuso horário atuais. GregorianCalendar define dois campos: AD e BC. Estes representam as duas eras definidas pelo calendário gregoriano.
Listados abaixo estão vários construtores do objeto GregorianCalendar:
número de série | Construtor e descrição |
1 | GregorianCalendar() Constrói um GregorianCalendar padrão usando a hora atual no fuso horário padrão com a localidade padrão. |
2 | GregorianCalendar(int ano, int mês, int data) Constrói um GregorianCalendar com as configurações de data fornecidas no fuso horário padrão com o local padrão |
3 | GregorianCalendar(int ano, int mês, int data, int hora, int minuto) Constrói um GregorianCalendar com as configurações de data e hora fornecidas para o fuso horário padrão com a localidade padrão. |
4 | GregorianCalendar(int ano, int mês, int data, int hora, int minuto, int segundo) Constrói um GregorianCalendar com as configurações de data e hora fornecidas para o fuso horário padrão com a localidade padrão. |
5 | GregorianCalendar(Locale aLocale) Constrói um GregorianCalendar com base na hora atual no fuso horário padrão com a localidade fornecida. |
6 | GregorianCalendar(TimeZone zone) Constrói um GregorianCalendar com base na hora atual em um determinado fuso horário com o código de idioma padrão. |
7 | GregorianCalendar(TimeZone zone, Locale aLocale) Constrói um GregorianCalendar com base na hora atual no fuso horário determinado com o local especificado. |
Aqui está uma lista de alguns métodos úteis fornecidos pela classe GregorianCalendar:
número de série | Métodos e instruções |
1 | void add(int field, int amount) Adiciona o período de tempo especificado (assinado) ao campo do calendário fornecido de acordo com as regras do calendário. |
2 | protected void computaFields() converte o valor de milissegundos UTC em valor de domínio de tempo |
3 | protected void computaTime() substitui o Calendário e converte o valor do domínio do tempo em milissegundos UTC |
4 | boolean equals(Object obj) Compara este GregorianCalendar com o Object especificado. |
5 | int get(int field) obtém o valor de tempo do campo especificado |
6 | int getActualMaximum(int field) retorna a data atual, o valor máximo do campo fornecido |
7 | int getActualMinimum(int field) retorna a data atual, o valor mínimo do campo fornecido |
8 | int getGreatestMinimum(int field) Retorna o valor mínimo mais alto para o campo de calendário fornecido nesta instância de GregorianCalendar. |
9 | Date getGregorianChange() Obtém a data de alteração do calendário gregoriano. |
10 | int getLeastMaximum(int field) Retorna o valor máximo mais baixo do campo de calendário fornecido para esta instância de GregorianCalendar |
11 | int getMaximum(int field) Retorna o valor máximo do campo de calendário fornecido para esta instância de GregorianCalendar. |
12 | Date getTime() obtém a hora atual do calendário. |
13 | long getTimeInMillis() obtém a hora atual do calendário representada por um número inteiro longo |
14 | TimeZone getTimeZone() obtém o fuso horário. |
15 | int getMinimum(int field) retorna o valor mínimo do campo fornecido. |
16 | int hashCode() substitui hashCode. |
17 | boolean isLeapYear(int year) determina se o ano determinado é um ano bissexto. |
18 | void roll(int field, boolean up) Adiciona ou subtrai (para cima/para baixo) uma única unidade de tempo do campo de tempo determinado, sem alterar campos maiores. |
19 | void set(int field, int value) define o campo de hora com o valor fornecido. |
20 | void set(int ano, int mês, int data) define o valor de ano, mês e dia. |
vinte e um | void set(int ano, int mês, int data, int hora, int minuto) define o valor de ano, mês, dia, hora e minuto. |
vinte e dois | void set(int ano, int mês, int data, int hora, int minuto, int segundo) define o valor de ano, mês, dia, hora, minuto e segundo. |
vinte e três | void setGregorianChange(Date date) define a data de alteração do GregorianCalendar. |
vinte e quatro | void setTime(Date date) define a hora atual do Calendário com a data especificada. |
25 | void setTimeInMillis(long millis) define a hora atual do Calendário com os longos milissegundos fornecidos. |
26 | void setTimeZone(TimeZone value) Define o fuso horário atual com o valor de fuso horário fornecido. |
27 | String toString() retorna uma string representando o calendário. |
importar java.util.*;
classe pública GregorianCalendarDemo {
public static void main(String args[]) {
String meses[] = {
"janeiro", "fevereiro", "março", "abril",
"maio", "junho", "julho", "agosto",
"Setembro", "Outubro", "Novembro", "Dezembro"};
ano interno;
// Inicializa o calendário gregoriano // Usa a hora e a data atuais // O padrão é a hora local e o fuso horário GregorianCalendar gcalendar = new GregorianCalendar();
// Exibe informações de hora e data atuais System.out.print("Date: ");
System.out.print(meses[gcalendar.get(Calendar.MONTH)]);
System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
System.out.println(ano = gcalendar.get(Calendário.ANO));
System.out.print("Hora: ");
System.out.print(gcalendar.get(Calendário.HORA) + ":");
System.out.print(gcalendar.get(Calendário.MINUTE) + ":");
System.out.println(gcalendar.get(Calendar.SECOND));
// Testa se o ano atual é bissexto if(gcalendar.isLeapYear(year)) {
System.out.println("O ano atual é um ano bissexto");
}
outro {
System.out.println("O ano atual não é bissexto");
}
}
}
Os resultados de compilação e execução do exemplo acima são os seguintes:
Data: 22 de abril de 2009
Hora: 11:25:27
O ano atual não é um ano bissexto
Para obter uma lista completa das classes do Calender, você pode consultar a documentação Java padrão.