1. Visão geral das datas em Java <r /> A data é uma peça de conteúdo muito complexa em Java. Para uma data em diferentes ambientes de idioma e país, a internacionalização das datas, a conversão entre datas e tempo, a adição e a subtração das datas e o formato de exibição das datas são questões muito complicadas.
Em Java, a data de operação envolve principalmente as seguintes classes:
1. Java.util.date
A data da classe representa um momento específico, preciso para milissegundos. Começando com o JDK 1.1, a classe do calendário deve ser usada para implementar a conversão entre os campos de data e hora, e a classe DateFormat deve ser usada para formatar e analisar strings de data. O método em data para interpretar as datas como ano, mês, dia, hora, minuto e segundo valores é abandonado.
2. Java.Text.DateFormat (Classe Resumo)
DateFormat é uma classe abstrata de subclasses de data/hora que formam e analisam datas ou horários de maneira independente do idioma. As subclasses de formatação de data/hora (como SimpleDateFormat) permitem formatação (ou seja, data-> texto), análise (texto-> data) e padronização. Denotar a data como objeto de data, ou como o número de milissegundos a partir do momento GMT (GMT) 1970, 1 de janeiro: 00:00:00.
3.
SimpleDateFormat é uma classe específica que formata e analisa as datas de maneira relacionada ao local. Permite formatação (data-> texto), análise (texto-> data) e normalização.
SimpleDateFormat permite selecionar qualquer modo de formato de data-hate-time definido pelo usuário. No entanto, ainda é recomendável usar o getTimeInstance, GetDateInstance ou GetDateTimeInstance no DateFormat para criar um novo formatador de encontro.
4. Java.util.Calendar (classe abstrata)
A classe do calendário é uma classe abstrata que fornece alguns métodos para converter um momento específico para um conjunto de campos de calendário, como ano, mês, dia_of_month, hora, etc., e fornece alguns métodos para manipular campos do calendário, como obter a data da próxima semana. O instante pode ser expresso como um valor de milissegundo, que é o deslocamento da época (ou seja, 00: 00: 00.000, GMT, 1 de janeiro de 1970, GMT).
Como outras classes sensíveis ao local, o calendário fornece um método de classe GetInstance para obter um objeto comum desse tipo. O método GetInstance do calendário retorna um objeto de calendário cujos campos de calendário foram inicializados pela data e hora atuais.
5.
O GregoriaCalendar é uma subclasse concreta do calendário que fornece um sistema de calendário padrão usado pela maioria dos países do mundo.
O GregoriaCalendar é um calendário híbrido que suporta os sistemas do calendário juliano e gregoriano com o apoio de uma única descontinuidade, que por padrão corresponde à data gregoriana quando o calendário gregoriano foi fundado (alguns países foram fundados em 15 de outubro de 1582 e mais tarde em outros). A data de início pode ser alterada pelo chamador ligando para o setgreghanChange ().
2. Uso de java.util.date
1. Introdução à API de Java.util.date
A classe java.util.date representa um momento específico, preciso para milissegundos. Existem muitos métodos fornecidos, mas muitos estão desatualizados e não são recomendados. Os seguintes listas seguintes apenas métodos que não estão desatualizados:
Resumo dos métodos de construção
------------------------
Data()
Atribua um objeto de data e inicialize esse objeto com o tempo atual para indicar o tempo em que foi alocado (preciso para milissegundos).
Data (data longa)
Atribua um objeto de data e inicialize esse objeto para representar o número especificado de milissegundos desde o tempo de referência padrão (chamado "Epoch", ou seja, 00:00:00 GMT em 1 de janeiro de 1970).
Resumo do método
------------------------
booleano depois (data em que)
Testes se esta data é após a data especificada.
booleano antes (data em que)
Testes se esta data é antes da data especificada.
Clone de objeto ()
Retorna uma cópia deste objeto.
int compare (data outro date)
Compare a ordem de duas datas.
BOOLEANOS iguais (objeto obj)
Compare a igualdade de duas datas.
long gettime ()
Retorna o número de milissegundos representados por esse objeto Data desde 1º de janeiro de 1970 00:00:00 GMT.
int hashcode ()
Retorna o valor do código de hash deste objeto.
Void Settime (longo tempo)
Defina este objeto de data para representar o tempo no tempo milissegundos após 00:00:00 GMT em 1º de janeiro de 1970.
String ToString ()
Converta este objeto de data em string da seguinte forma: Dow Mon DD HH: MM: SS ZZZ AYYY WHERE:
Dow é um dia da semana (Sun, Seg, Ter, Qua, qui, sex, sábado).
Mon é o mês (janeiro, fevereiro, março, abril, maio, junho, julho, agosto, setembro, outubro, novembro).
DD é um dia em janeiro (01 a 31) exibido como um número decimal de dois dígitos.
HH é a hora do dia (00 a 23), exibida como um número decimal de dois dígitos.
MM é a ata (00 a 59) na hora e é exibida como um número decimal de dois dígitos.
SS é o número de segundos (00 a 61) em um minuto, exibido como um número decimal de dois dígitos.
O ZZZ é o fuso horário (e reflete o horário de verão). A abreviação padrão do fuso horário inclui a abreviação de fuso horário reconhecido pelo Method Parse. Se as informações do fuso horário não forem fornecidas, o ZZZ está vazio, ou seja, nenhum caractere está incluído.
Aaaaa é um ano, exibida como um número decimal de 4 dígitos.
Aqui está um exemplo abrangente da classe de data:
classe pública testDate {public static void main (string [] args) {testDate testDate = new testDate (); testDate.getSystemCurrentTime (); testDate.getCurrentDate (); } / *** Obtenha o tempo atual do sistema* System.CurrentTimEmillis () Retorna o tempo atual do sistema e o resultado começa às 0:00:00 em 1º de janeiro de 1970. O número de milissegundos decorridos até a execução do programa e a obtenção do sistema () 1 {Systems SystemilT. (SystemSPROINT. tempo---"); System.out.println (System.CurrentTimEmillis ()); } public void getCurrentDate () {System.out.println ("--- obtenha a hora atual do sistema ---"); // Crie e inicialize uma data (o valor inicial é a data atual) data = new Date (); System.out.println ("A data atual é =" + date.toString ()); System.out.println ("O número de milissegundos experimentados desde 1º de janeiro de 1970 =" + date.gettime ()); }} 2. Uso de java.text.dateFormat Classe abstrata
DateFormat é uma classe abstrata de subclasses de data/hora que formam e analisam datas ou horários de maneira independente do idioma. As subclasses de formatação de data/hora (como SimpleDateFormat) permitem formatação (ou seja, data-> texto), análise (texto-> data) e padronização. Denotar a data como objeto de data, ou como o número de milissegundos a partir do momento GMT (GMT) 1970, 1 de janeiro: 00:00:00.
O DateFormat fornece vários métodos de classe para obter o formatador de data/hora padrão com base no local de inadimplência ou em vários estilos de formatação. Os estilos de formato incluem completo, longo, médio e curto. Mais detalhes e exemplos de uso desses estilos são fornecidos na descrição do método.
DateFormat ajuda a formatar e analisar as datas para qualquer local. Durante meses, semanas e até formatos de calendário (calendário lunar e solar), o código pode ser completamente irrelevante para as convenções do local.
Para formatar uma data no local atual, use um método estático de fábrica:
myString = dateFormat.getDateInstance (). formato (mydate);
Se você formatar várias datas, é mais eficiente obter o formato e usá -lo várias vezes, para que o sistema não precise obter informações sobre o idioma do ambiente e os acordos nacionais várias vezes.
DateFormat df = dateFormat.getDateInstance (); for (int i = 0; i <mydate.length; ++ i) {output.println (df.format (mydate [i]) +";"); }
Para formatar as datas de diferentes locais, especifique -o na chamada para getDateInstance ().
DateFormat df = dateFormat.getDateInstance (DateFormat.long, Locale.france);
DateFormat também pode ser usado para análise.
mydate = df.parse (mystring);
Use GetDateInstance para obter o formato de data padrão para esse país. Alguns outros métodos estáticos de fábrica também são fornecidos. Use GetTimeInstance para obter o formato de tempo para esse país. Use getDateTimeInstance para obter formatos de data e hora. Diferentes opções podem ser transmitidas para esses métodos de fábrica para controlar o comprimento do resultado (de curto a médio a longo e completo). O resultado exato depende do local, mas geralmente:
Short é completamente um número, como 12.13.52 ou 15:30
O meio é mais longo, como 12 de janeiro de 1952
Long é mais longo, como 12 de janeiro de 1952 ou 15:30:32
Full está totalmente especificado, como terça -feira, 12 de abril de 1952, ou 15:30:42 PST.
Se quiser, você também pode definir o fuso horário no formato. Se você deseja impor mais controle sobre a formatação ou análise (ou dar ao usuário mais controle), tente lançar o DateFormat obtido do método da fábrica para o SimpleDateFormat. Isso funciona para a maioria dos países; Lembre -se de colocá -lo em um bloco de tentativa em caso de formatos especiais.
Você também pode usar o método de análise e formatação com parseposição e fieldposition para analisar partes de uma string passo a passo. Alinhe qualquer campo específico ou descubra onde a string é selecionada na tela.
DateFormat não é síncrono. Recomenda -se criar instâncias de formato independentes para cada thread. Se vários threads acessarem um formato ao mesmo tempo, ele deve permanecer sincronizado externamente.
3. Uso de java.text.simpledateFormat (Subclasse Direct DateFormat Direct)
SimpleDateFormat é uma classe específica que formata e analisa as datas de maneira relacionada ao local. Permite formatação (data-> texto), análise (texto-> data) e normalização.
SimpleDateFormat permite selecionar qualquer modo de formato de data-hate-time definido pelo usuário. No entanto, ainda é recomendável usar o getTimeInstance, GetDateInstance ou GetDateTimeInstance no DateFormat para criar um novo formatador de encontro. Cada método de classe pode retornar um formatador de data/hora inicializado no modo de formato padrão. O padrão de formato pode ser modificado usando o método ApplyPattern, conforme necessário. Para obter mais informações sobre o uso desses métodos, consulte DateFormat.
Modo de data e hora
O formato de data e hora é especificado pela string de data e hora do padrão. Nas seqüências de dados de data e hora, as letras não citadas 'a' a 'z' e 'a' a 'z' são interpretadas como letras de padrão para representar elementos de string de data ou hora. O texto pode ser fechado em citações únicas (') para evitar a explicação. "''" significa citações únicas. Todos os outros personagens não são interpretados; Eles são simplesmente copiados para a sequência de saída quando formatados ou correspondidos com a sequência de entrada quando analisados.
Para obter mais informações de referência, você pode visualizar a documentação da API JDK. Aqui está um exemplo abrangente:
classe pública testDateFormat {public static void main (string [] args) lança parseException {testDateFormat tdf = new testDateFormat (); tdf.dateFormat (); } /*** Teste a classe SimpleDateFormat* @throws parseException* /public void dateFormat () lança parseException {// crie data data date = new Date (); // Crie diferentes formatos de data dateFormat df1 = dateFormat.getInstance (); DateFormat Df2 = new SimpleDateFormat ("AAAA-MM-01 HH: MM: SS EE"); DateFormat Df3 = DateFormat.GetDateInstance (DateFormat.full, Locale.china); // Crie um formato de data com um comprimento especificado do país especificado. O comprimento é diferente e a integridade da data exibida também é diferente. DATEFORMAT DF4 = NEW SimpleDateFormat ("AAA ANYYYY ANO MM MÊS DD DD HH HORA MM MIR MIND SS Seconds Ee", Locale.china); DateFormat df5 = new SimpleDateFormat ("AA YYYY-MM-DD HH: MM: SS EEEEEE", Locale.us); DateFormat df6 = novo SimpleDateFormat ("AAAA-MM-DD"); // datas de saída em diferentes formatos System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ df3.Format (Data); O System.Println ("De acordo com o formato especificado Aaaaaa-mm-DD, a área padrão do sistema:" + df6.format (data); Data Data2 = DF2.Parse ("2016-01-24 02:51:07 Domingo"); Data date3 = df3.parse ("2016-01-24"); Data Data4 = DF4.Parse ("2016-01-24 02:51:18 Domingo"); Data data6 = df6.parse ("2016-01-24"); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.Println (Date2); 4. Java.util.Calendar (classe abstrata)
java.util.Calendar é uma classe abstrata, uma representação abstrata do tempo do sistema. Ele fornece alguns métodos para converter um momento específico para um conjunto de campos de calendário, como ano, mês, dia_of_month, hour etc., e fornece alguns métodos para manipular campos de calendário (como obter a data da próxima semana). O instante pode ser expresso como um valor de milissegundo, que é o deslocamento da época (ou seja, 00: 00: 00.000, GMT, 1 de janeiro de 1970, GMT).
Como outras classes sensíveis ao local, o calendário fornece um método de classe GetInstance para obter um objeto comum desse tipo. O método GetInstance do calendário retorna um objeto de calendário cujos campos de calendário foram inicializados pela data e hora atuais.
Uma instância do calendário é uma representação abstrata do tempo do sistema. A partir da instância do calendário, você pode conhecer informações como ano, mês, dia, semana, mês e mês. Existe um método estático GET (INT X) na classe de calendário. Através deste método, você pode obter alguns valores (ano, mês, dia, semana, mês, etc.) informações da instância relevante. O parâmetro x é um valor de rendimento, definido no calendário.
Algumas armadilhas no calendário podem cair facilmente:
1. A semana do calendário começa no domingo, com um valor constante de 0.
2. O mês do calendário começa em janeiro, com um valor constante de 0.
3. O primeiro dia do calendário de cada mês é 1.
5.
O GregoriaCalendar é uma subclasse concreta do calendário que fornece um sistema de calendário padrão usado pela maioria dos países do mundo. Usado em conjunto com a classe abstrata do calendário.
Aqui está um exemplo abrangente para ver o uso da classe do calendário:
classe pública testCalendar {public static void main (string [] args) lança parseException {testCalendar testCalendar = new testCalendar (); testCalendar.TestCalendar (); testCalendar.testCalendar2 (); } public void testCalendar () {// como criar calendário calendário calendário agora1 = calendar.getInstance (); Calendário agora2 = new Gregoriancalendar (); Calendário agora3 = New Gregoriancalendar (2016, 01, 24); Calendário agora4 = New Gregoriancalendar (2016, 01, 24, 15, 55); // trilha: o mês do calendário é 0 ~ 11 calendário agora5 = New GregorianCalendar (2016, 01, 24, 15, 55, 44); Calendário agora6 = new Gregoriancalendar (loce.us); Calendário agora7 = new GregoriaNCalendar (TimeZone.GetTimeZone ("GMT-8: 00")); // defina calendário agora2.setTime (new Date ()); System.out.println (agora2); agora2.setTimeInmillis (new Date (). getTime ()); System.out.println (agora2); // Defina o formato de saída chinês da data e a saída A data simplouFormat DF = new SimpleDateFormat ("AA YYYYY ANO MM MORN DD DIA DO HH HORA MM MIND SS Seconds E", Locale.China); System.out.println ("Obtenha a saída formatada chinesa da data:" + df.format (agora5.getTime ())); System.out.println (); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Sistema; Sistema): System.Println (" Get Year: " + Now.Get (calendar.year); agora5.get (calendário.month); agora5.get (calendário.second); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- "March", "April", "Maio", "Junho", "Julho", "August", "Setembro", "Octo de outubro", "Novembro", "Dezembro"}; System.out.println ("Now5 Object's Month é:" + meses [agora5.get (calendar.month)]); } public void testCalendar2 () lança parseexception {// obtém o número máximo de dias no calendário atual do mês = calendar.getInstance (); int maxday = cal.getActualMaximum (calendar.day_of_month); int MindDay = cal.getActualMinimum (calendar.day_of_month); System.out.println (maxday); // Pegue o último dia do mês DateFormat Formatter3 = new SimpleDateFormat ("AAAA-MM-"+Maxday); System.out.println (format3.Format (cal.gettime ())); // Tome o último dia do mês DateFormat Formatter4 = new SimpleDateFormat ("AAAA-MM-"+MINDAY); System.out.println (formatter4.Format (cal.gettime ())); // Encontre o número de dias entre duas datas java.text.simpledateFormat formato = new java.text.simpledEformat ("yyyy-mm-dd"); java.util.date begindate = format.parse ("2007-12-24"); java.util.date enddate = format.parse ("2007-12-25"); dia longo = (enddate.getTime ()-begindate.gettime ())/(24*60*60*1000); System.out.println ("Número de dias de distância ="+dia); // Data de um ano atrás java.text.format formatter5 = new java.text.simpledateFormat ("yyyy-mm-dd"); java.util.date Todaydate = new java.util.date (); longo beforetime = (TodayDate.getTime ()/1000) -60*60*24*365; Todaydate.setTime (Beforetime*1000); String beforedate = formatter5.Format (TodayDate); System.out.println (bateue); Calendário calendário = calendário.getInstance (); calendário.add (calendário.year, -1); System.out.println (formatter5.Format (calendar.gettime ())); // A segunda e domingo da semana atual SimpledateFormat DateFormat = new SimpleDateFormat ("AAYYYMMDD"); GregoriaNCalendar GregoriaCalendar = New GregorianCalendar (); int Dayinweek = gregoriancalendar.get (calendar.day_of_week); int offset = 0; if (DayinWeek == 1) {// Offset de domingo = 6; } else {// de segunda a sábado Offset = DayinWeek - 2; } gregoriancalendar.add (gregoriancalendar.day_of_month, -offset); String sday = dateFormat.Format (GregoriaNCalendar.getTime ()); GregoriaCalendar.add (GregoriaNCalendar.Day_Of_MONTH, 6); String eday = dateFormat.Format (GregoriaCalendar.getTime ()); System.out.println ("Segunda -feira desta semana:" + sday); System.out.println ("Domingo desta semana:" + Eday); }}3. Resumo
Muitas vezes, existem cinco aspectos das datas em Java:
1. Data de criação
2. Exibição do formato de data
3. Conversão de data (principalmente conversão mútua com strings)
4. Obtenha as datas da meia -idade, mês, dia, hora, minuto, segunda, semana, mês, etc.
5. Comparação do tamanho da data e adição e subtração de datas.
O método de uso de data e hora acima está o Java resumido para você. Espero que seja útil para o seu aprendizado.