java 中两个日期字符串之间的差异

Question

I am trying to calculate difference between two date strings both of which are taken from user through a html form in format (yyyy/MM/dd) Code:

public boolean diffDate() throws ParseException
 {
     date1 = getissuedate();
     date2 = getduedate();
         Calendar cal1 = Calendar.getInstance();
    Calendar cal2 = Calendar.getInstance();
    SimpleDateFormat formatter1 = new SimpleDateFormat("yyyy/MM/dd");
    SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy/MM/dd"); 
Date date_old = formatter1.parse(date1);
Date date_new = formatter2.parse(date2);
long milis1 = date_old.getTime();
long milis2 = date_new.getTime();

long diff = milis2 - milis1;       

    if( diff<3 || diff>3)
    {
        return true;
    }
    else 
    {       
        return false;
    }       
 }

Now am using an if condition to report error in my webpage if difference between the date is not equal to 3. Code:

try {
        if(diffDate())
        {
            errors.add("duedate", new ActionMessage("error.duedate.required"));
        }
    } catch (ParseException ex) {
        Logger.getLogger(IssueBookForm.class.getName()).log(Level.SEVERE, null, ex);
    }

where error.duedate.required is mapped to "check date"

So, the issue is "check date" error is printed for any value of both date string.

Answer 1

You're testing if two dates differ by 3 milliseconds, which will almost always be true. If you really want 3 days, the value should be 3*86400*1000. If you care about what happens with leap-seconds and daylight-savings-time changes, then the problem gets more complex.

Answer 2

Your condition diff<3 || diff>3 is equivalent to diff.= 3 and diff is expressed in milliseconds. This expression will never be true.

Answer 3

If you parse dates with a resolution of 1 day, ie 86.000.000 milliseconds, you will never get a situation where they are exactly 3 ms different.

getTime() returns the time in ms since "the start of the epoch", so it returns milliseconds, or 1/1000 s.

diff < 3 || diff > 3

is the same as

diff != 3

If you want to detect dates which are exactly 3 days different, you could divide the number of millis by the number of ms/day before comparing.

Answer 4

you'll never get a difference of exactly 3 milliseconds between two dates gotten from a yyyy/MM/dd formatted string (maximum accuracy will be 24 hours)

if you want 3 days difference use 24*60*60*1000 for a factor to scale the values

Answer 5

java.util.Calendar has a method add , that takes a quantity and a unit of time, and a method called compareTo , that takes another calendar. You should be using those.

Answer 6

tl;dr

java.lang.Math.abs (
    ChronoUnit.DAYS.between(
        LocalDate.parse( "2017/01/23".replace( "/" , "-" ) ) ,
        LocalDate.parse( "2017/02/14".replace( "/" , "-" ) ) 
    )
) > 3L

Using java.time

The modern approach uses the java.time classes rather than the troublesome old legacy date-time classes ( Date , Calendar , and such).

Your input strings almost comply with the standard ISO 8601 format for date-only values: YYYY-MM-DD. To fully comply, replace the slash characters with hyphen characters.

String inputA = "2017/01/23".replace( "/" , "-" ) ;
String inputB = "2017/02/14".replace( "/" , "-" ) ;

The java.time classes by default use the standard formats when parsing/generating strings. So no need to specify a formatting pattern.

LocalDate ldA = LocalDate.parse( inputA );
LocalDate ldB = LocalDate.parse( inputB );

The rest of your Question does not make sense as it tests for +/- three milliseconds which cannot ever be true between dates. Apparently you meant to check for a count of days. For that, use the ChronoUnit enum.

long daysBetween = ChronoUnit.DAYS.between( ldA , ldB );

If the second date actually occurs before the first date, the result is a negative number. You seem to want to test for either case, using a tolerance of ±3. Use the java.lang.Math class' abs method to test absolute value of our result.

The ChronoUnit.DAYS.between method returns a long primitive. So our test comparing that result to our limit of three must match that type. Note the use of the L to indicate that 3L is a primitive value of three of type long . The compiler might upgrade the default of 3 from int (32-bit) to long (64-bit), but I prefer to be explicit by using 3L .

if( abs( daysBetween ) > 3L ) { … }

---

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date , Calendar , & SimpleDateFormat .

The Joda-Time project, now in maintenance mode , advises migration to the java.time classes.

To learn more, see the Oracle Tutorial . And search Stack Overflow for many examples and explanations. Specification is JSR 310 .

Where to obtain the java.time classes?

• Java SE 8 , Java SE 9 , and later
  • Built-in.
  • Part of the standard Java API with a bundled implementation.
  • Java 9 adds some minor features and fixes.
• Java SE 6 and Java SE 7
  • Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport .
• Android
  • The ThreeTenABP project adapts ThreeTen-Backport (mentioned above) for Android specifically.
  • See How to use ThreeTenABP… .

The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval , YearWeek , YearQuarter , and more .