1. Descripción general de las fechas en Java <Br /> La fecha es una pieza de contenido muy compleja en Java. Para una fecha en diferentes entornos de idiomas y países, la internacionalización de las fechas, la conversión entre fechas y tiempo, la adición y resta de las fechas y el formato de visualización de fechas son problemas muy complicados.
En Java, la fecha de operación implica principalmente las siguientes clases:
1. Java.util.date
La fecha de clase representa un momento específico, preciso para milisegundos. Comenzando con JDK 1.1, la clase de calendario debe usarse para implementar la conversión entre los campos de fecha y hora, y la clase DateFormat debe usarse para formatear y analizar las cadenas de fecha. Se abandona el método en la fecha para interpretar las fechas como año, mes, día, hora, minuto y segundos valores.
2. Java.text.dateformat (clase abstracta)
DateFormat es una clase abstracta de subclases de formato de fecha/hora que formatan y analizan fechas o tiempos de manera independiente del lenguaje. Subclases de formato de fecha/hora (como SimpleDateFormat) Permitir formato (es decir, fecha-> texto), análisis (texto-> fecha) y estandarización. Denota la fecha como un objeto de fecha, o como el número de milisegundos a partir del momento GMT (GMT) 1970, 1 de enero, 00:00:00.
3. Java.text.simpledateFormat (subclase directo dateFormat)
SimpleDateFormat es una clase específica que formatea y analiza las fechas de manera relacionada con el local. Permite el formato (date-> texto), análisis (texto-> fecha) y normalización.
SimpleDateFormat le permite seleccionar cualquier modo de formato de tiempo de fecha definido por el usuario. Sin embargo, todavía se recomienda usar GetTimeInstance, GetDateInstance o GetDateTimeInstance en DateFormat para crear un nuevo formato de fecha.
4. Java.util.calendar (clase abstracta)
La clase de calendario es una clase abstracta que proporciona algunos métodos para convertir un momento específico a un conjunto de campos de calendario como año, mes, día_of_month, hora, etc., y proporciona algunos métodos para manipular los campos de calendario, como obtener la fecha de la próxima semana. El instante se puede expresar como un valor de milisegundo, que es el desplazamiento de la época (es decir, 00: 00: 00.000, GMT, 1 de enero de 1970, GMT).
Al igual que otras clases sensibles a locales, el calendario proporciona un método de clase GetInstance para obtener un objeto común de este tipo. El método GetInstance del calendario devuelve un objeto calendario cuyos campos de calendario se han inicializado mediante la fecha y hora actuales.
5. Java.util.gregoriancalendar (subclase directo del calendario)
Gregoriancalendar es una subclase concreta de calendario que proporciona un sistema de calendario estándar utilizado por la mayoría de los países del mundo.
Gregoriancalendar es un calendario híbrido que respalda los sistemas de calendario juliano y gregoriano con el apoyo de una sola discontinuidad, que por defecto corresponde a la fecha gregoriana cuando se fundó el calendario gregoriano (algunos países se fundaron el 15 de octubre de 1582 y luego en otros). La persona que llama puede cambiar la fecha de inicio llamando a SetGregorianChange ().
2. Uso de java.util.date
1. Introducción a la API de java.util.date
La clase java.util.date representa un momento específico, preciso para milisegundos. Se proporcionan muchos métodos, pero muchos están desactualizados y no se recomiendan. Los siguientes enumeran solo métodos que no están desactualizados:
Resumen de métodos de construcción
----------------------
Fecha()
Asigne un objeto de fecha e inicialice este objeto con la hora actual para indicar la hora en que se asignó (preciso a milisegundos).
Fecha (fecha larga)
Asigne un objeto de fecha e inicialice este objeto para representar el número especificado de milisegundos desde la hora de referencia estándar (llamada "época", es decir, 00:00:00 GMT el 1 de enero de 1970).
Resumen de métodos
----------------------
booleano después (fecha cuando)
Prueba si esta fecha es después de la fecha especificada.
booleano antes (fecha cuando)
Prueba si esta fecha es antes de la fecha especificada.
Clon de objeto ()
Devuelve una copia de este objeto.
int Compareto (Fecha de otro Date)
Compare el orden de dos fechas.
booleano es igual (obj obj)
Compare la igualdad de dos fechas.
Long GetTime ()
Devuelve el número de milisegundos representados por este objeto de fecha desde el 1 de enero de 1970 00:00:00 GMT.
int hashcode ()
Devuelve el valor del código hash de este objeto.
Settime vacío (mucho tiempo)
Establezca este objeto de fecha para representar los milisegundos de tiempo en el tiempo después de las 00:00:00 GMT del 1 de enero de 1970.
Cadena toString ()
Convierta este objeto de fecha a la cadena de la siguiente forma: Dow Mon Dd HH: MM: SS ZZZ YYYY DONDE:
Dow es un día de la semana (sol, lunes, martes, mié, jueves, viernes, sábado).
Mon es el mes (enero, febrero, marzo, abril, mayo, junio, julio, agosto, septiembre, octubre, nov, dec).
DD es un día de enero (01 a 31) que se muestra como un número decimal de dos dígitos.
HH es la hora del día (00 a 23), que se muestra como un número decimal de dos dígitos.
MM son las actas (00 a 59) en la hora y se muestra como un número decimal de dos dígitos.
SS es el número de segundos (00 a 61) en un minuto, que se muestra como un número decimal de dos dígitos.
ZZZ es la zona horaria (y refleja el tiempo de ahorro de verano). La abreviatura estándar de la zona horaria incluye la abreviatura de la zona horaria reconocida por el análisis del método. Si no se proporciona información de la zona horaria, ZZZ está vacío, es decir, no se incluyen caracteres.
Yyyy es un año, que se muestra como un número decimal de 4 dígitos.
Aquí hay un ejemplo completo de la clase de fecha:
public class testDate {public static void main (string [] args) {testDate testDate = new testDate (); testDate.getSystemCurrentTime (); testDate.getCurrentDate (); } / *** Obtenga la hora actual del sistema* System.CurrentTimemillis () Devuelve la hora actual del sistema, y el resultado comienza a las 0:00:00 el 1 de enero de 1970. El número de milisegundos transcurrido hasta que la ejecución del programa y obteniendo el tiempo del sistema* 1 segundo = 1000 MilliseConds* / public void void getSystemCurrentTime () {System.out.PrintLn ("------------") System.out.println (System.CurrentTimemillis ()); } public void getCurrentDate () {System.out.println ("--- Obtenga el tiempo actual del sistema ---"); // Crear e inicializar una fecha (el valor inicial es la fecha actual) Fecha de fecha = nueva fecha (); System.out.println ("La fecha actual es =" + date.ToString ()); System.out.println ("El número de milisegundos experimentados desde el 1 de enero de 1970 =" + date.gettime ()); }} 2. Uso de Java.Text.DateFormat Resumen Clase
DateFormat es una clase abstracta de subclases de formato de fecha/hora que formatan y analizan fechas o tiempos de manera independiente del lenguaje. Subclases de formato de fecha/hora (como SimpleDateFormat) Permitir formato (es decir, fecha-> texto), análisis (texto-> fecha) y estandarización. Denota la fecha como un objeto de fecha, o como el número de milisegundos a partir del momento GMT (GMT) 1970, 1 de enero, 00:00:00.
DateFormat proporciona una serie de métodos de clase para obtener un formateador de fecha/hora predeterminado en función de los estilos de formato de establecimiento predeterminado o dados y múltiples. Los estilos de formato incluyen completo, largo, mediano y corto. Se proporcionan más detalles y ejemplos de uso de estos estilos en la descripción del método.
DateFormat ayuda a formatear y analizar fechas para cualquier localidad. Durante meses, semanas e incluso formatos de calendario (calendario lunar y solar), el código puede ser completamente irrelevante para las convenciones locales.
Para formatear una fecha en la localidad actual, use un método de fábrica estática:
myString = dateFormat.getDateInStance (). Format (myDate);
Si formatea múltiples fechas, es más eficiente obtener el formato y usarlo varias veces, para que el sistema no tenga que obtener información sobre el lenguaje del medio ambiente y los acuerdos nacionales varias veces.
DateFormat df = dateFormat.getDateInStance (); for (int i = 0; i <mydate.length; ++ i) {output.println (df.format (myDate [i]) +";"); }
Para formatear las fechas de diferentes lugares, especifíquelo en la llamada a getDateInstance ().
DateFormat df = dateFormat.getDateInStance (dateFormat.long, locale.france);
DateFormat también se puede utilizar para el análisis.
myDate = df.parse (myString);
Use GetDateInstance para obtener el formato de fecha estándar para ese país. También se proporcionan algunos otros métodos de fábrica estática. Use GetTimeInstance para obtener el formato de tiempo para ese país. Use getDateTimeInstance para obtener formatos de fecha y hora. Se pueden pasar diferentes opciones a estos métodos de fábrica para controlar la longitud del resultado (de corto a medio a largo a largo). El resultado exacto depende de la ubicación, pero generalmente:
El corto es completamente un número, como las 12.13.52 o las 3:30 p.m.
El medio es más largo, como el 12 de enero de 1952
Largo es más largo, como el 12 de enero de 1952 o 3:30:32 pm
El completo se especifica completamente, como el martes 12 de abril de 1952 AD o 3:30:42 PM PST.
Si lo desea, también puede configurar la zona horaria en el formato. Si desea imponer más control sobre el formato o el análisis (o dar al usuario más control), puede intentar lanzar el formato date obtenido del método de fábrica a SimpleDateFormat. Esto funciona para la mayoría de los países; Solo recuerda ponerlo en un bloque de try en caso de formatos especiales.
También puede usar el método de análisis y formato con parsposición y posición de campo para analizar partes de una cadena paso a paso. Alinee cualquier campo específico o descubra dónde se selecciona la cadena en la pantalla.
DateFormat no es sincrónico. Se recomienda crear instancias de formato independientes para cada hilo. Si múltiples hilos acceden a un formato al mismo tiempo, debe permanecer sincronizado externamente.
3. Uso de java.text.simpledateFormat (subclase directo dateFormat)
SimpleDateFormat es una clase específica que formatea y analiza las fechas de manera relacionada con el local. Permite el formato (date-> texto), análisis (texto-> fecha) y normalización.
SimpleDateFormat le permite seleccionar cualquier modo de formato de tiempo de fecha definido por el usuario. Sin embargo, todavía se recomienda usar GetTimeInstance, GetDateInstance o GetDateTimeInstance en DateFormat para crear un nuevo formato de fecha. Cada método de clase puede devolver un formato de fecha/hora inicializado en el modo de formato predeterminado. El patrón de formato se puede modificar utilizando el método ApplyPattern según sea necesario. Para obtener más información sobre el uso de estos métodos, consulte DateFormat.
Modo de fecha y hora
El formato de fecha y hora se especifica mediante la cadena de patrón de fecha y hora. En las cadenas de patrones de fecha y hora, las letras no cotizadas 'A' a 'Z' y 'A' a 'Z' se interpretan como letras de patrón para representar elementos de cadena de fecha o hora. El texto se puede encerrar en cotizaciones individuales (') para evitar explicaciones. "''" significa citas individuales. Todos los demás personajes no son interpretados; Simplemente se copian a la cadena de salida cuando están formateados, o coinciden con la cadena de entrada cuando se analizan.
Para obtener más información de referencia, puede ver la documentación de la API JDK. Aquí hay un ejemplo completo:
public class testDateFormat {public static void main (string [] args) lanza ParseException {testDateFormat tdf = new testDateFormat (); tdf.dateformat (); } /*** Pruebe la clase SimpleDateFormat* @throws parseException* /public void dateFormat () lanza ParseException {// Crear fecha de fecha = nueva fecha (); // crear diferentes formatos de fecha dateFormat df1 = dateFormat.getInstance (); DateFormat df2 = new SimpleDateFormat ("aaa yyy-mm-01 hh: mm: ss ee"); DateFormat df3 = dateFormat.getDateInStance (dateFormat.full, locale.china); // Crear un formato de fecha con una longitud especificada del país especificado. La longitud es diferente, y la integridad de la fecha que se muestra también es diferente. DateFormat df4 = new SimpleDateFormat ("yyyyy año mm mes dd dd hh hora mm minuto ss segundos ee", locale.china); DateFormat df5 = new SimpleDateFormat ("aaa yyy-mm-dd hh: mm: ss eeeeee", locale.us); DateFormat df6 = new SimpleDateFormat ("yyyy-mm-dd"); // Fechas de salida en diferentes formatos System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- df3.Format (date)); df5.Format (date)); Fecha fecha2 = df2.parse ("2016-01-24 02:51:07 domingo"); Fecha fecha3 = df3.parse ("2016-01-24"); Fecha fecha4 = df4.parse ("2016-01-24 02:51:18 domingo"); Fecha fecha6 = df6.parse ("2016-01-24"); System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println(date1); System.out.println (date2); 4. Java.util.calendar (clase abstracta)
java.util.calendar es una clase abstracta, una representación abstracta del tiempo del sistema. Proporciona algunos métodos para convertir un momento específico a un conjunto de campos calendario como año, mes, día_of_month, hora, etc., y proporciona algunos métodos para manipular los campos calendario (como obtener la fecha de la próxima semana). El instante se puede expresar como un valor de milisegundo, que es el desplazamiento de la época (es decir, 00: 00: 00.000, GMT, 1 de enero de 1970, GMT).
Al igual que otras clases sensibles a locales, el calendario proporciona un método de clase GetInstance para obtener un objeto común de este tipo. El método GetInstance del calendario devuelve un objeto calendario cuyos campos de calendario se han inicializado mediante la fecha y hora actuales.
Una instancia de calendario es una representación abstracta del tiempo del sistema. Desde la instancia del calendario, puede conocer información como año, mes, día, semana, mes y mes. Hay un método estático Get (Int X) en la clase de calendario. A través de este método, puede obtener algunos valores (año, mes, día, semana, mes, etc.) información de la instancia relevante. El parámetro X es un valor de rendimiento, definido en el calendario.
Algunas trampas en el calendario pueden caer fácilmente:
1. La semana del calendario comienza el domingo, con un valor constante de 0.
2. El mes del calendario comienza desde enero, con un valor constante de 0.
3. El primer día del calendario de cada mes es 1.
5. Java.util.gregoriancalendar (subclase directo del calendario)
Gregoriancalendar es una subclase concreta de calendario que proporciona un sistema de calendario estándar utilizado por la mayoría de los países del mundo. Utilizado junto con la clase abstracta del calendario.
Aquí hay un ejemplo completo para ver el uso de la clase de calendario:
Public Class TestCalendar {public static void main (String [] args) lanza ParseException {testCalendar testCalendar = new testCalendar (); testCalendar.TestCalendar (); testCalendar.TestCalendar2 (); } public void testCalendar () {// cómo crear calendario calendario calendario ahora1 = calendar.getInstance (); Calendario ahora2 = nuevo Gregoriancalendar (); Calendario ahora3 = nuevo Gregoriancalendar (2016, 01, 24); Calendario ahora4 = nuevo Gregoriancalendar (2016, 01, 24, 15, 55); // Trail: el mes del calendario es 0 ~ 11 calendario ahora5 = nuevo Gregoriancalendar (2016, 01, 24, 15, 55, 44); Calendario ahora6 = nuevo Gregoriancalendar (locale.us); Calendario ahora7 = nuevo Gregoriancalendar (TimEzone.gettimezone ("GMT-8: 00")); // Establecer calendario ahora2.setTime (nueva fecha ()); System.out.println (ahora2); ahora2.settimeinmillis (nueva fecha (). getTime ()); System.out.println (ahora2); // Defina el formato de salida chino de la fecha y la salida de la fecha SimpledateFormat df = new SimpleDateFormat ("aaa yyyy año mm mes dd dd hh hora mm minuto ss segundos e", locale.china); System.out.println ("Obtenga la salida de la fecha en formateado chino:" + df.format (ahora5.gettime ())); System.out.println (); System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System; System.out.println("Get year: " + now5.get(Calendar.YEAR)); System.out.println("Get month (month starts from 0): " + Now5.get (calendar.month); ahora5.get (calendar.second); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- "Marzo", "Abril", "May", "June", "Julio", "Agosto", "Septiembre", "octubre", "noviembre", "diciembre"}; System.out.println ("Now5 El mes del objeto es:" + meses [ahora5.get (calendar.month)]); } public void testCalendar2 () lanza ParseException {// Obtenga el número máximo de días en el calendario de mes actual cal = calendar.getInstance (); int maxday = cal.getActualMaximum (calendar.day_of_month); int Mindday = cal.getActualMinimum (calendar.day_of_month); System.out.println (Maxday); // Toma el último día del mes dateFormat Formatter3 = new SimpleDateFormat ("aaa yyy-mm-"+maxday); System.out.println (format3.format (cal.gettime ())); // Toma el último día del mes dateFormat Formatter4 = new SimpleDateFormat ("aaa yyy-mm-"+minday); System.out.println (formatter4.format (cal.gettime ())); // Encuentra el número de días entre dos fechas java.text.simpledateformat format = new java.text.simpledateFormat ("yyyy-mm-dd"); java.util.date begindate = format.parse ("2007-12-24"); java.util.date enddate = format.parse ("2007-12-25"); día largo = (enddate.gettime ()-begindate.gettime ())/(24*60*60*1000); System.out.println ("Número de días separados ="+día); // Fecha hace un año java.text.format formatter5 = new java.text.simpledateFormat ("yyyy-mm-dd"); java.util.date TodayDate = new java.util.date (); Long befeforetime = (TodayDate.GetTime ()/1000) -60*60*24*365; TodayDate.setTime (Beforetime*1000); Cadena beforedate = formatter5.Format (TodayDate); System.out.println (Beforedate); Calendario calendario = calendario.getInstance (); calendario.add (calendario.year, -1); System.out.println (formatter5.Format (calendar.gettime ())); // el lunes y domingo de la semana actual SimpleDateFormat dateFormat = new SimpleDateFormat ("yyyymmdd"); Gregoriancalendar Gregoriancalendar = new Gregoriancalendar (); int dayinweek = gregoriancalendar.get (calendar.day_of_week); int offset = 0; if (dayInWeek == 1) {// Sunday Offset = 6; } else {// desplazamiento de lunes a sábado = dayInweek - 2; } gregoriancalendar.add (Gregoriancalendar.day_of_month, -Offset); Cadena sday = dateFormat.Format (Gregoriancalendar.gettime ()); Gregoriancalendar.add (Gregoriancalendar.day_of_month, 6); Cadena eday = dateFormat.Format (Gregoriancalendar.gettime ()); System.out.println ("Lunes de esta semana:" + Sday); System.out.println ("Domingo de esta semana:" + eday); }}3. Resumen
A menudo hay cinco aspectos de las fechas en Java:
1. Fecha de creación
2. Visualización de formato de fecha
3. Conversión de fecha (principalmente conversión mutua con cadenas)
4. Obtenga las fechas de mediana edad, mes, día, hora, minuto, segundo, semana, mes, etc.
5. Comparación del tamaño de la fecha y suma y resta de las fechas.
Lo anterior es el método de uso de la fecha y la hora de Java resumido para usted. Espero que sea útil para su aprendizaje.