El propósito de este puesto es proporcionar una guía paso a paso para desarrollar una utilidad que tendrá la siguiente funcionalidad:
1) Esta utilidad ayudará a validar un formato de fecha introducido por el usuario.
2) Si los datos introducidos por el usuario son válidos, entonces serán convertibles a un formato que se pueda insertar fácilmente en la base de datos.
Dado que la fecha puede ser introducida por el usuario en cualquier formato, se hace difícil validarla y el formato podría no ser aceptable para ser insertado también en la base de datos. Por consiguiente, es necesario validar si los datos introducidos por el usuario están en un formato válido o no y luego hay que convertirlo en un formato que pueda insertarse fácilmente en la base de datos.
Desarrollo de la utilidad:
Necesita importar primero los siguientes paquetes:
importar java.sql.Date;
importar java.text.ParsePosition;
importar java.text.SimpleDateFormat;
importar java.util.ArrayList;
La siguiente clase de java proporcionará la funcionalidad requerida:
Programa llamado:
[code language=»java»]
clase pública DateFormatter {
set de cuerdas públicasDisplayEffectiveDate(String date) {
ArrayList validDateList = new ArrayList();
validDateList.add(«dd-MMM-yyyy»);
validDateList.add(«dd.MM.yyyy»);
validDateList.add(«dd/MM/aaaa»);
validDateList.add(«MM/dd/yyyy»);
Date effectiveDate = null;
System.out.println(«setDisplayEffectiveDate1 :: date = » + date);
if (date != null) {
booleano correctoFormato = falso;
int i = 0;
String dateFormat = null;
// Volver a analizar la cadena anterior en una Fecha.
ParsePosition pos = new ParsePosition(0);
System.out.println («setDisplayEffectiveDate2 :: date = » + date);
while (!correctFormat)
{
si (i > validDateList.size() – 1)
{
…romper;
}
//para (int j=0;j<validDateList.size();j++)
//{
dateFormat = validDateList.get(i++).toString().trim();
System.out.println(«setDisplayEffectiveDate3 :: dateFormat = «+ dateFormat);
prueba
{
SimpleDateFormat fmt =
nuevo SimpleDateFormat(dateFormat);
fmt.setLenient(false);
effectiveDate = nuevo Date(fmt.parse(date,pos).getTime());
//log.debug(«setDisplayEffectiveDate2 :: dateFormat = «+ dateFormat);
//log.debug(«setDisplayEffectiveDate2 :: effectiveDate = «+ effectiveDate);
correctFormat = true;
}
captura (Excepción e)
{
//log.debug(«setDisplayEffectiveDate3 :: dateFormat = «+ dateFormat);
correctFormat = false;
}
//}
}
System.out.println(«setDisplayEffectiveDate :: correctFormat = » + correctFormat);
System.out.println(«setDisplayEffectiveDate2 :: effectiveDate = «+ effectiveDate);
si (!correctFormat) {
// EffectiveDate = new Date();
System.out.println(«setDisplayEffectiveDate :: effectiveDate (error) = «+ effectiveDate);
}
}
java.sql.Date sDate = new java.sql.Date(effectiveDate.getTime());
SimpleDateFormat fmt1 = nuevo SimpleDateFormat(«dd-MMM-yyyy»);
devuelve fmt1.format(sDate);
}
}
[/código]
Descripción
- Definimos una clase java – ‘DateFormatter.java’ que contendrá la lógica para validar una fecha introducida por el usuario.
- Dentro de la clase definimos el método – ‘setDisplayEffectiveDate(String date)’ con un parámetro que tomará la fecha introducida por el usuario como una cadena.
- Definimos una lista en forma de array ‘validDateList’ que contendrá todos los formatos de fecha posibles con los que se validará la fecha introducida por el usuario. Por ejemplo, en el caso anterior, tomamos sólo 4 formatos, es decir, dd-MMM-aaaa, dd.MM.aaaa, dd/MM/aaaa, MM/dd/aaaa. La fecha introducida por el usuario debe pertenecer a cualquiera de estos formatos. Sin embargo, si necesitamos que se permitan más formatos de fecha, podemos seguir agregándolos a la lista de arreglos y la fecha introducida por el usuario será validada contra eso.
- Entonces comprobamos si la fecha introducida por el usuario no es nula o no.
[code language=»java»]
si (fecha != nula) {
….
booleano correctFormat = false; // Fijar el valor booleano falso inicialmente
ParsePosition pos = nueva ParsePosition(0);
….
}[/code]
La ParsePosition es una clase simple utilizada por Format y sus subclases para llevar un registro de la posición actual durante el análisis sintáctico. El método parseObject en las distintas clases de Format requiere un objeto ParsePosition como argumento.
- Hacemos un bucle de tiempo que se repite hasta que la fecha introducida por el usuario coincide con cualquiera de los formatos de fecha definidos en la lista del array. Una vez que coincide, sale del bucle.
Dentro del bucle while hacemos lo siguiente:
[code language=»java»]
mientras que (!correctFormat) {
….
dateFormat = validDateList.get(i++).toString().trim(); // Obtiene el primer formato de fecha de la lista de arreglos
….
Intenta…
// El formato de fecha obtenido anteriormente se establece en el constructor de la clase Formato de Fecha Simple
SimpleDateFormat fmt = nuevo SimpleDateFormat(dateFormat);
fmt.setLenient(false);
// Encuentra la fecha/hora efectiva usando el constructor de la clase Date
effectiveDate = new Date(fmt.parse(date,pos).getTime());
// Poniendo el valor booleano como ‘true’ si se obtiene la fecha efectiva y salir del bucle while.
correctFormat = true;
} catch (Excepción e) {
correctFormat = falso;
// Si no, establezca el valor booleano como false y continúe con el bucle while.
}
}[/código]
Nota:
- SimpleDateFormat es una clase concreta para dar formato y analizar las fechas de una manera sensible a la localidad. Permite el formato (fecha -> texto), el análisis sintáctico (texto -> fecha) y la normalización. SimpleDateFormat permite empezar eligiendo cualquier patrón definido por el usuario para el formato de fecha y hora.
- El método SimpleDateFormat.setLenient() establece un valor que determina si el análisis sintáctico se establece como indulgente para este objeto DateFormat. La indulgencia está determinada por el objeto ‘Calendar’ asociado a esta instancia. La clase Calendar contiene métodos y miembros para realizar operaciones básicas que implican días, semanas, meses y años.
- La clase ‘Fecha’ representa un instante específico en el tiempo, con precisión de milisegundos.
- El método SimpleDateFormat.parse(String source, ParsePosition pos) parseará una cadena de fecha/hora de acuerdo a la posición de parse dada.
- El método getTime() te proporciona el recuento total de milisegundos que han pasado desde el 1 de enero de 1970
- Una vez que se obtiene la fecha efectiva, se le da un formato de fecha que puede ser fácilmente insertado en la base de datos.
[code language=»java»]
java.sql.Date sDate = new java.sql.Date(effectiveDate.getTime());
SimpleDateFormat fmt1 = nuevo SimpleDateFormat(«dd-MMM-yyyy»);
[/código]
- En caso de que la fecha introducida por el usuario no coincida con ninguno de los formatos definidos, entonces lanzará una excepción que se manejará en el bloque de captura.
Programa de llamada:
[code language=»java»]
clase pública Inicio
{
vacío estático público principal(String[] args) {
Inténtalo.
// Parte 2 para el formato de la fecha
Start start = nuevo Start();
DateFormatter dateformat = new DateFormatter(); // La clase definida arriba
Datos de la cadena = «26/11/1952»; // Usuario – fecha introducida. Dada como un ejemplo aquí.
// Llamando al método de la clase Date Formatter
data = start.isNull(dateformat.setDisplayEffectiveDate(data));
System.out.println(«Datos de fecha válida después del formato – «+datos»);
}catch(Excepción e)
{
System.out.println(«Excepción en el método principal-Inicio() :»+e);
System.out.println(«Por favor, introduzca una fecha válida :»);
}
}
String privado esNull(String string)
{
// Convierte el valor nulo en una cadena en blanco
si (string==null || «».es igual a(string.trim()) )
{
…regresar..;
}
devuelve string.trim();
}
}[/código]
Salida:
setDisplayEffectiveDate1 :: date = 26/11/1952
setDisplayEffectiveDate2 :: date = 26/11/1952
setDisplayEffectiveDate3 :: dateFormat = dd-MMM-yyyy
setDisplayEffectiveDate3 :: dateFormat = dd.MM.yyyy
setDisplayEffectiveDate3 :: dateFormat = dd/MM/yyyy
setDisplayEffectiveDate :: correctFormat = true
setDisplayEffectiveDate2 :: effectiveDate = 1952-11-26
Fecha válida Datos después del formato – 26-Nov-1952
