It is so frustrating when people leave off the declarations from code
snippets. Half the time the problem is with the declarations. And you
can't make sense of procedural code without the declarations.

First of all, I'm assuming you used java.sql.Timestamp, not
java.security.Timestamp. Please verify that you are also using
java.sql.Timestamp.

I used the following code and observed some interesting results:

Timestamp modifiedDate = new Timestamp(System.currentTimeMillis() + 10001);

System.out.println("modifiedDate timestamp: " + modifiedDate.toString());

Timestamp lastEditTimestamp = new Timestamp(System.currentTimeMillis());

System.out.println("lastEditTimestamp timestamp: " +
lastEditTimestamp.toString());

if (modifiedDate.getTime() - lastEditTimestamp.getTime() > 10000) {

   System.out.println("modifiedDate more than 10,000 milliseconds after
lastEditTimestamp");

}

In _most_ but NOT all cases, this code worked fine; the difference of 10001
milliseconds is detected as being greater than 10000 milliseconds and the
message in the last println() statement is printed. But in a _few_ cases,
the if statement did not detect a sufficient difference to trigger the
message.

I seem to recall reading that timestamps in Java are not accurate to the
millisecond, let alone the nanosecond. If I remember correctly, the
precision of timestamps is only roughly 0.05 seconds. I suspect that this is
the cause of the inconsistent behaviour. Therefore, if you get your
timestamps from Java, e.g Ssytem.currentTimeMillis(), you can't
realistically expect the precision you want.

If you can't live with that, I think your only hope is to acquire your
timestamps outside of the Java where you can get better precision.

But my memory is not that great so please don't take my remarks to the bank;
I may be misremembering the precision of timestamps and there may be some
reasonable way to get sufficiently precise timestamps.

Rhino