La mayor parte de la aplicación Java incluye datos de formato de fecha y cálculos relacionados. Cálculo de la diferencia entre dos fechas. valores es una de las operaciones importantes y que se realizan con frecuencia.

El siguiente código muestra cómo obtener la diferencia entre dos valores de fecha. Comprobaremos si la diferencia de fechas entre las dos fechas proporcionadas es superior a 30 meses.

1. método getDateDiff : Este método calcula la diferencia entre dos fechas

2. StrTokens : Este método analiza el valor de fecha especificado y obtiene la parte del año, mes y día de la fecha especificada. El método getDateDiff utilizará estas partes de año, mes y día al calcular la diferencia.

Método: getDateDiff

[code language=”java”]

public static String getDateDiff (String strStartDate, String strEndDate)
{
int iStartDay, iEndDay, iStartMonth, iEndMonth, iStartYear, iEndYear = 0;
int iStartDate, iEndDate, iDateDiff = 0;
if (strStartDate.trim (). equals (“”) || strEndDate.trim (). equals (“”))
{
return (“Éxito”);
}
otro
{
String strDelim = “/”;
StrTokens StartDate = new StrTokens (strStartDate, strDelim);
StrTokens EndDate = new StrTokens (strEndDate, strDelim);
iStartYear = StartDate.getIYear ();
iEndYear = EndDate.getIYear ();
iStartMonth = StartDate.getIMonth ();
iEndMonth = EndDate.getIMonth ();
iStartDay = StartDate.getIDate ();
iEndDay = EndDate.getIDate ();
iStartYear = iStartYear * 12;
iEndYear = iEndYear * 12;
iStartDate = iStartYear + iStartMonth;
iEndDate = iEndYear + iEndMonth;
iDateDiff = iEndDate – iStartDate;

if (iDateDiff> = 29) {
Calendario c = new GregorianCalendar ();
String firstDate = strStartDate;
String secondDate = strEndDate;
DateFormat df = DateFormat.getDateInstance (DateFormat.SHORT);
Date fdate, sdate, newFDate;
intentar {
fdate = df.parse (firstDate);
sdate = df.parse (secondDate);
c.setTime (fdate);
c.add (Calendar.MONTH, 30);
log.debug (“newFDate” + c.getTime ());
newFDate = c.getTime ();

if (newFDate.after (sdate) || newFDate.equals (sdate))
{
log.debug (“newFDate es anterior a la sdate”);
log.debug (“La diferencia no supera los 30 meses”);
return (“Éxito”);
}} catch (ParseException e) {
log.debug (“error” + e);
}

leer  Datos de Java: convierte el formato de 12 horas al formato de 24 horas y viceversa

log.debug (“La diferencia es más de 30 meses”);
return (“Fallido”);
}
otro
{
log.debug (“La diferencia no supera los 30 meses”);
return (“Éxito”);
}

}
}
[/code]

Método / Constructor: StrTokens

[code language=”java”]

import java.util.StringTokenizer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

StrTokens de clase pública {
privado int iYear;
privado int iMonth;
private int iDate;

/ **
* @return Devuelve iDate.
* /
public int getIDate () {
return iDate;
}
/ **
* @param date El iDate que se va a establecer.
* /
setIDate public void (fecha int) {
iDate = fecha;
}
/ **
* @return Devuelve iMonth.
* /
public int getIMonth () {
return iMonth;
}
/ **
* @param mes El iMonth a establecer.
* /
public void setIMonth (int mes) {
iMonth = mes;
}
/ **
* @return Devuelve iYear.
* /
public int getIYear () {
return iYear;
}
/ **
* @param year El año de iYear que se va a establecer.
* /
public void setIYear (int año) {
iYear = año;
}
StrTokens públicos (String strTxt, String strDelim)
{
String origTxt = new String ();
Cadena Delímetro = nueva Cadena ();
int longitud = 0;
origTxt = strTxt;
delímetro = strDelim;
int delimLen = delímetro.longitud ();
int startTokInd = 0;
int curDelimIndex = origTxt.indexOf (delímetro);
StringTokenizer str = nuevo StringTokenizer (strTxt, strDelim);
int iCountTokens = str.countTokens ();
Soga[] token = nueva cadena [iCountTokens];
int i = 0;

while (str.hasMoreTokens ())
{
tokens[i]= str.nextToken ();
i ++;
}
this.setIMonth (nuevo Integer (tokens[0]) .intValue ());
this.setIYear (new Integer (tokens[2]) .intValue ());
this.setIDate (new Integer (tokens[1]) .intValue ());
}
}[/code]

El método getDateDiff pasará la fecha de inicio y la fecha de finalización al constructor StrTokens.
Este constructor analizará la fecha y obtendrá parte del año, mes y día de la fecha especificada.
A continuación, el método getDateDiff comprueba si la diferencia de fecha entre la fecha de inicio y la fecha de finalización es superior a 30 meses. Este método luego devolverá un valor de bandera que indica éxito / fracaso.

leer  Java LocalDateTime

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *