• Author / Uploaded
• Euclides Marin

Citation preview

Operaciones No todo debe ser tan complejo y abstracto como lo es con las clases que vimos anteriormente. Java posee otras clases que nos facilitan realizar operaciones como suma, resta, obtener un día y hora exactos, entre otras. Estas funcionalidades las obtenemos de dos clases en particular; una es abstracta: java.util.Calendar (a partir de ahora me referiré a ella como Calendar) y permite obtener campos enteros como día, mes y año de objetos de tipo java.util.Date o que hereden de él. La otra java.util.GregorianCalendar (a partir de ahora simplemente GregorianCalendar) es una implementación del calendario gregoriano que es usado en casi todo el mundo (es el que conocemos). Calendar Según la documentación del API de java, la clase Calendar es una clase abstracta base para convertir entre un objeto de tipo Date (java.util.Date) y un conjunto de campos enteros como YEAR (año), MONTH (mes), DAY (día), HOUR (hora), etc. Una subclase de Calendar representa una fecha de acuerdo a las reglas de un calendario específico. La plataforma provee una subclase concreta de Calendar: GregorianCalendar. Futuras subclases podrían representar varios tipos de calendarios lunares usados en diferentes lugares del mundo. Esto puede haber sonado un tanto abstracto pero no nos confundamos. La clase Calendar tiene mucho del comportamiento que esperaríamos de la clase java.util.Date, es decir, cuando obtenemos una instancia de la clase Calendar obtenemos un instante de tiempo específico con gran precisión similar a lo que obtenemos con la clase date. Sí es cierto, podemos decir aquí que los milisegundos juegan un papel fundamental en esta clase; pero el verdadero sentido de la clase Calendar no es obtener un instante de tiempo sino extraerle datos. Recordemos que la clase java.util.Date tiene métodos que permiten obtener el año, mes y día, pero estos métodos están obsoletos precisamente por que para eso existe Calendar y de hecho cuando usamos el método getYear() de la clase java.util.Date esta recurre a las funcionalidades que posee la clase Calendar. Hay que mencionar también que obtener un instante de tiempo específico y diferente del actual es supremamente sencillo con esta clase, indicándole simplemente el día, mes y año con que se desea trabajar, o se puede especificar aún más dando hora, minuto y segundo deseado. Veamos: El método getInstance() de la clase nos devuelve una subclase de Calendar con el tiempo ajustado a la hora actual, y usamos el método set(args…) para forzarlo a tomar la fecha deseada: Calendar ahoraCal = Calendar.getInstance(); System.out.println(ahoraCal.getClass()); ahoraCal.set(2004,1,7); System.out.println(ahoraCal.getTime()); ahoraCal.set(2004,1,7,7,0,0); System.out.println(ahoraCal.getTime());

La primera línea devuelve una instancia de GregorianCalendar con la fecha y hora actual y el método getTime() retorna un objeto de tipo java.util.Date que se muestra en consola posteriormente. En la tercera línea se usa el método set para ajustar la fecha al "7 de enero de 2004" y en la quinta ponemos la misma fecha pero esta vez ajustando también la hora, minutos y seg qundos,

comoueda: "7 de la noche del 7 de enero de 2004". La salida en consola será (note que tiene el formato de java.util.Date): class java.util.GregorianCalendar Sat Feb 07 19:55:47 GMT-05:00 2004 Sat Feb 07 07:00:00 GMT-05:00 2004

Extraer los datos La clase Calendar tiene un único método get para obtener todos sus datos para lo cual se ayuda de una serie de atributos constantes que permiten obtener o ajustar un atributo determinado de la fecha; los más importantes son (al lado los valores que representan): -YEAR: Año. -MONTH: Mes. -DATE, DAY_OF_MONTH: Día del mes. -DAY_OF_WEEK: Día de la semana entre 1 (MONDAY) y 7 (SATURDAY). -HOUR: Hora antes o después del medio día (en intervalos de 12 horas). -HOUR_OF_DAY: Lo hora absoluta del día (en intervalos de 24 horas). -MINUTE: El minuto dentro de la hora. -SECOND: El segundo dentro del minuto. Están también los atributos que representan los meses, como: JANUARY, MARCH, JUNE, DECEMBER, etc. que van desde 0 (JANUARY) hasta 11 (DECEMBER). También hay atributos que representan los días: SUNDAY, TUESDAY, SATURDAY, etc. estos empiezan con 1 (SUNDAY) y van hasta 7 (SATURDAY). Hay más atributos pero con estos es suficiente para los objetivos de este artículo, si deseas concerlos todos recurre a la documentación del lenguaje. Para extraer algún atributo se usa el método get pasándole como parámetro alguna de las constantes que vimos anteriormente y el método devuelve siempre un dato de tipo int; así para obtener el año , mes, día y hora, usaríamos el siguiente código: System.out.println("ANYO: "+ahoraCal.get(Calendar.YEAR)); System.out.println("MES: "+ahoraCal.get(Calendar.MONTH)); System.out.println("DIA: "+ahoraCal.get(Calendar.DATE)); System.out.println("HORA: "+ahoraCal.get(Calendar.HOUR)); if (ahoraCal.get(Calendar.MONTH) == Calendar.JUNE){ System.out.println("ES JUNIO"); }else{ System.out.println("NO ES JUNIO"); }

Si el objeto tiene la fecha equivalente a 5:30 p.m. del 22 de junio de 2004 se ve la siguiente salida: ANYO: 2004 MES: 5 DIA: 22 HORA: 5 ES JUNIO

Modificar un atributo Modificar un atributo de Calendar es tan sencillo como obtenerlo, solamente es necesario usar el método set(int atributo, int valor), en donde atributo es una de las constante mencionadas anteriormente y valor es la cantidad que se le quiere asignar. Por ejemplo: ahoraCal.set(Calendar.MONTH,Calendar.JANUARY) o ahoraCal.set(Calendar.YEAR, 1980) ajustarían la fecha almacenada en el objeto ahoraCal a enero o al año 1980 sin modificar ninguno de los otros atributos. Aclaremos esto con un ejemplo. Mi cumpleaños es en octubre 27 :-), y deseo saber que día lo celebraré en el 2010; para eso obtengo una instancia de Calendar (que siempre devuelve un objeto del tipo GregorianCalendar) y la ajusto hasta el 27 de octubre de 2010, luego obtengo el nombre del dia, veamos: Calendar cumpleCal = Calendar.getInstance(); cumpleCal.set(2010,9,27); //La hora no me interesa y recuerda que los meses van de 0 a 11 int dia = cumpleCal.get(Calendar.DAY_OF_WEEK); System.out.println(dia); //Día 4 = WEDNESDAY = MIÉRCOLES

La salida es: 4, lo que quiere decir que en el 2010 el 27 de octubre será un día miércoles (así que probablemente lo celebre el viernes 29 :-)); Clase GregorianCalendar y operaciones Realizar operaciones como sumar o restar días no es algo que dependa directamente de Calendar sino más bien de una subclase de esta que implemente algún tipo de calendario usado, pues no todos los calendarios tienen 12 meses ni años de 365 días como el que nosotros (en casi todo occidente) usamos. Este calendario usado en occidente, llamado gregoriano fue adoptado por primera vez en 1582 por el imperio romano (o aproximadamente) y posteriormente se fue adoptando en muchos otros países, por ejemplo 1752 en Gran Bretaña y 1918 en Rusia. A grandes rasgos sabemos que el calendario gregoriano consta de años que son definidos por cada traslación (vuelta de la tierra alrededor del sol), cada año tiene doce meses de los cuales 7 tienen 31 días, 4 tienen 30 días y 1 tiene 28 días excepto en años bisiestos que tiene 29. Estos años bisiestos se implantaron para corregir el desfase que tenemos cada cuatro años (un año real dura 365 días y 6 horas aproximandamente), regla completa para los años bisiestos según en calendario gregoriano es la siguiente: "Un año es bisiesto si es divisible por 4, a menos que sea divisible por 100 y no por 400". Todo esto quizá suene un poco tonto, pero es absolutamente necesario tenerlo claro para entender el funcionamiento de la clase GregorianCalendar. GregorianCalendar es una subclase de Calendar y es la implementación directa del calendario gregoriano (de hecho es la única implementación de un calendario en jdk1.4) tal y como lo conocemos hoy día. Es con esta clase con la que podemos sumar 2 ó 3 días a una fecha sin preocuparnos por desbordamientos o recalcular meses o años, pues ella lo hace automáticamente tomando en cuenta las reglas en los párrafos anteriores. De igual forma podemos obtener información como el día de la semana o la semana del año que fue una fecha determinada.

Los métodos roll() y add() Anteriormente vimos los métodos set() y get() de la clase Calendar para obtener fechas y los datos de esas fechas, ahora veremos los métodos add() y roll() que nos permiten avanzar un tiempo exacto sobre los datos obtenidos anteriormente. El método add(CONSTATE, valor) suma algebraicamente valor a una fecha; el valor a sumar asume el significado dado por CONSTANTE, que es una de las definidas para la clase y que se mencionaron en la sección anterior (MONTH, YEAR, SECOND, etc). Por ejemplo agreguemos 3 días y 2 meses a la fecha actual: Calendar hoy = Calendar.getInstance(); hoy.add(Calendar.DATE, 3); hoy.add(Calendar.MONTH, 2); System.out.println(hoy.getTime());

Ahora restemos 5 años y 50 días (Prúebalo en tu PC): Calendar hoy = Calendar.getInstance(); hoy.add(Calendar.YEAR, -5); hoy.add(Calendar.DATE, -50); System.out.println(hoy.getTime());

¿Qué, restar 50 días? Pues sí, resulta que la clase GregorianCalendar es “inteligente” al momento de hacer estos cálculos y se basa en ciertas reglas (2 según la documentación) para realizar estas operaciones; tal y como nosotros lo haríamos al sumar 50 días, cuando lleguemos al final del mes actual empezamos a contar a partir del mes siguiente y lo mismo si cambiara el año, es decir, cuando llegue al límite superior o inferior de uno de estos intervalos se empezará a afectar el intervalo siguiente según la lógica de la operación. Para aclarar lo anterior debemos conocer el orden de los campos que se han mencionado en el artículo (solo pondré los más significativos); aquí van en orden descendente: YEAR MONTH DATE, DAY_OF_MONTH HOUR MINUTE SECOND Cuando estamos sumando los campos se afectan de abajo hacia arriba (SECOND – YEAR) y restando el orden es inverso (YEAR – SECOND), así que al momento de restar 50 días se decrementa el atributo DAY_OF_MONT (o DATE) hasta 1, luego se decrementa en 1 el atributo MONTH y DAY_OF_MONTH inicia en el número de días del mes; si antes de decrementar MONTH está en su límite inferior (JANUARY) YEAR también debe ser recalculado (disminuye en 1) y MONTH regresa a su límite superior al igual que DATE. Que enredo! Es cierto, todo esto puede parecer un laberinto (especialmente por que no me explico bien), pero estoy seguro que con un poco de código se despejará el panorama. Para todos los ejemplos partiremos del 10 de noviembre de 1998 a las 7:00am.

Calendar cal = Calendar.getInstance(); cal.set(1998,10,10,7,0,0); cal.add(Calendar.SECOND,52); cal.add(Calendar.HOUR, 2); cal.add(Calendar.MONTH, -3); cal.add(Calendar.YEAR,1); //Así la fecha seía 1999/8/10 09:00:52 (Agosto 10 de 1999) System.out.println(cal.getTime());

Aquí ningún atributo llegó a su límite superior o inferior y por tanto la nueva fecha se calcula muy fácilmente. Para ver como incide una sola operación en varios atributos, sumaremos a la fecha 70 minutos y 22 días; como el límite superior de los minutos (60) es sobrepasado, se debe incrementar el atributo inmediatamente superior (HOUR), igual que al sobrepasar el límite de días para el mes (noviembre tiene 30 días) se incrementa el año. Así finalmente tendremos el 2 de diciembre de 1998 a las 8:10 am. cal.add(Calendar.MINUTE, 70); cal.add(Calendar.DATE, 22); //Así la fecha seía 1998/12/2 08:10:00 (Diciembre 2 de 1998) System.out.println(cal.getTime());

Método roll(CONSTATE, valor) Esté método tiene un funcionamiento similar a add() excepto por que no modifica ningún otro atributo, es decir, cuando el atributo dado por CONSTANTE llega a su límite inferior o superior cambia al límite contrario pero sin modificar sus atributos siguientes. Seguramente suena un tanto extraño este funcionamiento, pues con el método set() podemos asignar un valor directamente; según la documentación este método se hizo para facilitar la funcionalidad en las interfaces de usuario donde hay que especificar una fecha y tienen botones para incrementar o decrementar alguno de los datos (creo que todos los hemos visto). Si en el ejemplo anterior en vez de add() usamos roll() ya no obtendremos Diciembre 2 de 1998 a 8:10 am, sino Noviembre 2 de 1998 a las 7:10 am. Note que solo cambian los valores que se especificaron directamente. cal.roll(Calendar.MINUTE, 70); cal.roll(Calendar.DATE, 22); //Así la fecha seía 1998/11/2 07:10:00 (Noviembre 2 de 1998) System.out.println(cal.getTime());

En verdad el uso de roll no es muy común excepto pues en ambientes gráficos, los métodos que en verdad deben ser considerados, estudiados y probados son set(), get() y add(). Esto es todo por esta entrega, en el próximo artículo veremos como formatear una fecha para mostrarla de forma comprensible, el parseo y algunos detalles no tan comunes de las clases Calendar y GregorianCalendar.

Cómo manejar fechas en Java Miércoles, septiembre 29th, 2010

Como no podía ser menos, el primer artículo tenía que estar relacionado con el lenguaje de programación Java. El manejo de fechas en Java puede resultar en un principio un poco menos intuitivo que en otros lenguajes tales como PHP o Visual Basic. Sin embargo, para trabajar con fechas de una forma más cómoda, contamos con la clase java.util.Calendar. Calendar es una clase base abstracta con la que podremos representar y manejar fechas (objetos de tipo Date), así como modificar y obtener sus datos enteros tales como YEAR, MONTH, DAY, etc… Para instanciar un objeto de clase Calendar, tendremos 2 opciones:  

Opción A: Utilizar el método getInstance(), que nos proporcionará un objeto Calendar cuyos campos han sido inicializados con la fecha y la hora actuales. Opción B: Utilizar el constructor de la clase GregorianCalendar. Esta clase es a su vez una subclase de java.util.Calendar, que nos proporciona un calendario estándar usado comunmente en la mayor parte del mundo.

A continuación mostramos el código de las 2 opciones mencionadas: ? 1Date date = new Date(); 2Calendar calendar1 = Calendar.getInstance(); 3Calendar calendar2 = new GregorianCalendar(); Una vez instanciado el objeto Calendar, ya podemos manejar las fechas a nuestro antojo. ¿Cómo extraer los datos individuales de la fecha? ¿A que os suenan los famosos getters y setters…? pues esta clase no iba a ser menos. La clase java.util.Calendar nos proporciona un único método get(int field) para extraer cualquier atributo del calendario que indiquemos en el atributo field, tal y como veremos a continuación en el siguiente código de ejemplo. NOTA: Ten en cuenta que valores como el mes o el día de la semana comienzan por 0, no por 1. ? // Instanciamos el objeto Calendar

1Calendar calendar = Calendar.getInstance(); 2// Obtenemos el valor del año, mes y día. 3int year = calendar.get(Calendar.YEAR); 4int month = calendar.get(Calendar.MONTH); date = calendar.get(Calendar.DATE); 5int System.out.println("AÑO ACTUAL: " + year);

6System.out.println("MES ACTUAL: " + month); 7System.out.println("DÍA ACTUAL: " + date); 8 9 ¿Cómo modificar los atributos o valores de la fecha? Al igual que disponemos del método get(int field) para obtener cualquier valor de una fecha, disponemos también del método set(int field, int value) para modificarlo. Deberemos pasar 2 parámetros:  

field: atributo de la fecha que queremos modificar value: nuevo valor a asignar

Veamos a continuación un ejemplo de cómo modificar los atributos año, mes y día: ? 1calendar.set(Calendar.YEAR, 2020); calendar.set(Calendar.MONTH, 02); // OJO: Recueda que los valores de los 2meses comienzan por 0. 3calendar.set(Calendar.DATE, 30); Además del método simple set(int field, int value), disponemos también de 3 métodos más sobrecargados set que nos permitirán asignar fechas completas en un único paso: ? 1// Asignamos año, mes y día. 2calendar.set(2020, 02, 30); 3// Asignamos año, mes, día, horas y minutos. 4calendar.set(2020, 02, 30, 19, 00); 5// Asignamos año, mes, día, horas, minutos y segundos. calendar.set(2020, 02, 30, 19, 00, 55); 6 ¿Cómo sumar y restar fechas? He aquí uno de los métodos más útiles cuando queremos operar con fechas: add(int field, int amount). Con la misma estructura que el método set(int field, int amount), podremos sumar (y por lo tanto restar) cantidades de diferentes valores a una fecha.  

field: atributo de la fecha que queremos modificar y cuya cantidad pasaremos en el parámetro amount amount: cantidad a sumar o restar (valores negativos) a la fecha

Viajemos en el tiempo y rejuvenezcamos 10 años: ?

1// Sumamos 30 minutos a la fecha actual. 2calendar.add(Calendar.MINUTE, 30); 3// Sumamos 100 días a la fecha actual. 4calendar.add(Calendar.DATE, 100); 5// Restamos 10 años a la fecha actual. calendar.add(Calendar.YEAR, -10); 6 Para más información sobre la clase Calendar podéis acceder también a la documentación de Sun (o de Oracle, como más os guste). Espero que el artículo os haya sido de utilidad. Como habéis comprobado, la clase Calendar nos facilita la vida cuando queremos manejar fechas en java, y es muy fácil e intuitiva de utilizar. En próximas entregas, veremos cómo realizar más operaciones con fechas. El manejo de las fechas en java el temor de muchos el placer de otros. Pero de ahora en adelante ya no sera así jugaremos y reiremos con estas. Empezaremos este articulo nombrando a la clase Date del paquete java.util que es la representación de un instante de tiempo especifico en milisegundos, esta esta clase tiene muchos métodos ya deprecados por lo tanto no se recomienda el uso de ellos, por tal motivo realizaremos la mayor parte del manejo de las fechas y horas con las clases Calendar y GregorianCalendar del mismo paquete java.util. Estas clases nos hacen mucho mas fácil la obtención de datos referentes a una fecha. GregorianCalendar es una subclase de Calendar, esta ultima esta definida como abstracta y posee una serie de constantes publicas que nos permiten obtener dicha información como por ejemplo:     

YEAR => Año MONTH => Mes (0-11) DAYOFMONTH => Dia del Mes (0 - [28,29,30,31] depende del mes y año) HOUROFDAY => Hora (0 - 23) etc...

y por otro lado el formato de las fechas y horas para mostrarlas al usuario final las trabajaremos con la clase SimpleDateFormat. Empecemos, para trabajar con la fecha y hora actual del sistema debemos obtener una instancia de GregorianCalendar de la siguiente forma: Calendar c = GregorianCalendar.getInstance();

este método getInstance esta definido en la clase Calendar devuelve un Calendar con base en la zona horaria. Ahora veremos como podemos hacer uso de la fecha y hora tanto para consultar como para manipular, gracias a estas clases. Lo primero que vamos a trabajar es la consulta de campos que

nos interesen por ejemplo; obtendremos el año, mes, dia del mes, hora, minutos, segundos y hasta el día del año de la instancia que ya tenemos: int int int int int int int ...

ano = c.get(Calendar.YEAR); mes = c.get(Calendar.MONTH); diaDelMes = c.get(Calendar.DAY_OF_MONTH); hora = c.get(Calendar.HOUR_OF_DAY); minutos = c.get(Calendar.MINUTE); segundos = c.get(Calendar.SECOND); diaDelAno = c.get(Calendar.DAY_OF_YEAR);

Y todo así de fácil, También encontramos constantes definidas para los meses y días de la semana por ejemplo Calendar.JANUARY, Calendar.MONDAY, ... y eso es todo así de sencillo, ahora veremos algunas formas de modificar los datos de la fecha a través de los métodos set, add y roll set: nos permite modificar el valor de un campo correspondiente a la instancia de GregorianCalendar, tiene 4 variaciones la mas usada es la que recibe el valor del campo que se va a modificar y el valor a establecer asi: c.set(Calendar.YEAR, 2008);

y listo así de fácil le hemos indicado que el año es 2008. add: como vimos ahora mismo la fecha tiene el año 2008 si queremos indicarle que es dos años mas basta con llamar a add así: c.add(Calendar.YEAR, 2); c.add(Calendar.HOUR, 25);

una característica importante de esta función es que si aumentamos un valor como el ejemplo donde decimos que sume 25 horas modifica todos los atributos por ejemplo para mi caso hoy es 20 de Julio del 2009 y después de estos cambios es 21 de Julio del 2010. roll: este método funciona de manera muy similar al set excepto porque este no acomoda los otros atributos como lo hace el set. Ahora pasaremos a formatear fechas para de mostrarcelas a los usuarios finales, como comente anteriormente trabajaremos con la clase SimpleDateFormat, esta clase pertenece al paquete java.text y uno de sus tres constructores recibe un String que representa el formato en que queremos mostrar las fechas pro ejemplo: SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");

lo que al formatear mediante el metodo format una fecha daría como resultado algo así: 2010/07/24 format recibe un objeto Date el cual obtendremos de nuestra instancia de GregorianCalendar a

través del método getTime el cual nos retorna un Date que representa el instante de tiempo de nuestra fecha. por ejemplo: System.out.println(dateFormat.format(c.getTime()));

la clase SimpleDateFormat también nos permite obtener un objeto Date a través de una cadena de texto así: try { Date d = dateFormat.parse("2010/07/24"); System.out.println(dateFormat.format(d)); } catch (ParseException ex) { ex.printStackTrace();

} como observamos este método lanza una Excepción de tipo java.text.ParseException en caso tal que la cadena no represente una fecha valida. public abstract clase Calendar extends Object se extiende de objetos implements Serializable , Cloneable implementa Serializable , Cloneable Calendar

is an abstract base class for converting between a Date object and a set of integer fields such as YEAR , MONTH , DAY , HOUR , and so on. Calendar es una clase base abstracta para la conversión entre una Date objeto y un conjunto de campos enteros como YEAR , MONTH , DAY , HOUR , y así sucesivamente. (A Date object represents a specific instant in time with millisecond precision. See Date for information about the Date class.) (A Date objeto representa un instante concreto en el tiempo con precisión de milisegundos. Vea Date de información sobre la Date de clase.) Subclasses of Calendar interpret a Date according to the rules of a specific calendar system. Las subclases de Calendar interpretar una Date de acuerdo a las reglas de un sistema de calendario específico. The JDK provides one concrete subclass of Calendar : GregorianCalendar . El JDK proporciona una subclase concreta de Calendar : GregorianCalendar . Future subclasses could represent the various types of lunar calendars in use in many parts of the world. subclases futuras podrían presentar los diferentes tipos de calendarios lunares en uso en muchas partes del mundo. Like other locale-sensitive classes, Calendar provides a class method, getInstance , for getting a generally useful object of this type. Calendar 's getInstance method returns a GregorianCalendar object whose time fields have been initialized with the current date and time: Al igual que otras clases sensibles-regional, Calendar proporciona un método de clase, getInstance , para obtener un objeto de utilidad general de este tipo. Calendar 's getInstance

método devuelve un GregorianCalendar objeto cuyo tiempo de los campos se han iniciado con la fecha y hora actuales: Calendar rightNow = Calendar.getInstance(); Calendario RightNow = Calendar.getInstance ();

A Calendar object can produce all the time field values needed to implement the date-time formatting for a particular language and calendar style (for example, Japanese-Gregorian, Japanese-Traditional). Un Calendar objeto puede producir todo el campo de valores de tiempo necesarios para implementar el tiempo el formato de fechas para un idioma en particular y el estilo del calendario (por ejemplo, japonés gregoriano, japonés tradicional). When computing a Date from time fields, two special circumstances may arise: there may be insufficient information to compute the Date (such as only year and month but no day in the month), or there may be inconsistent information (such as "Tuesday, July 15, 1996" -- July 15, 1996 is actually a Monday). Al calcular la Date de los campos de tiempo, dos circunstancias especiales que puedan surgir: puede haber suficiente información para calcular la Date (por ejemplo, sólo año y mes, pero no hay día en el mes), o puede haber información contradictoria (por ejemplo, "martes, 15 de julio 1996 "- 15 de julio de 1996 es en realidad un lunes). Insufficient information. The calendar will use default information to specify the missing fields. La falta de información. El calendario se utiliza la información predeterminada para especificar los campos que faltan. This may vary by calendar; for the Gregorian calendar, the default for a field is the same as that of the start of the epoch: ie, YEAR = 1970, MONTH = JANUARY, DATE = 1, etc. Esto puede variar según el calendario, pues el calendario gregoriano, el valor predeterminado para un campo es el mismo que el del inicio de la época: es decir, AÑO = 1970 = MES DE ENERO DE FECHA = 1, etc Inconsistent information. If fields conflict, the calendar will give preference to fields set more recently. información incoherente. Si el conflicto campos, el calendario se dará preferencia a los campos de conjunto más recientemente. For example, when determining the day, the calendar will look for one of the following combinations of fields. Por ejemplo, la hora de determinar el día, el calendario se busque una de las siguientes combinaciones de campos. The most recent combination, as determined by the most recently set single field, will be used. La combinación más recientes, según lo determinado por el campo de la más reciente conjunto único y se utilizará. MONTH + DAY_OF_MONTH MES + DAY_OF_MONTH MONTH + WEEK_OF_MONTH + DAY_OF_WEEK MES + + WEEK_OF_MONTH DAY_OF_WEEK MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK MES + + DAY_OF_WEEK_IN_MONTH DAY_OF_WEEK DAY_OF_YEAR DAY_OF_YEAR DAY_OF_WEEK + WEEK_OF_YEAR DAY_OF_WEEK + WEEK_OF_YEAR

For the time of day: Para la hora del día: HOUR_OF_DAY HOUR_OF_DAY

AM_PM + HOUR Am_pm + HORA

Note: for some non-Gregorian calendars, different fields may be necessary for complete disambiguation. Nota: para algunos-los calendarios gregoriano no, los diferentes campos que sean necesarias para la desambiguación completa. For example, a full specification of the historial Arabic astronomical calendar requires year, month, day-of-month and day-of-week in some cases. Por ejemplo, una especificación completa del historial astronómicos del calendario árabe exige año, mes, día de mes y día de la semana en algunos casos. Note: There are certain possible ambiguities in interpretation of certain singular times, which are resolved in the following ways: Nota: Hay algunos posibles ambigüedades en la interpretación de ciertos momentos singulares, que se resuelven de la siguiente manera: 1. 24:00:00 "belongs" to the following day. 24:00:00 "pertenece" al día siguiente. That is, 23:59 on Dec 31, 1969 < 24:00 on Jan 1, 1970 < 24:01:00 on Jan 1, 1970 Es decir, las 23:59 del 31 de diciembre 1969