如何计算两个Java Java.sql之间的差异。时间戳?

经过一个小时和各种单元测试,我想出了这个解决方案:

public static Timestamp diff (java.util.Date t1, java.util.Date t2)
{
    // Make sure the result is always > 0
    if (t1.compareTo (t2) < 0)
    {
        java.util.Date tmp = t1;
        t1 = t2;
        t2 = tmp;
    }

    // Timestamps mix milli and nanoseconds in the API, so we have to separate the two
    long diffSeconds = (t1.getTime () / 1000) - (t2.getTime () / 1000);
    // For normals dates, we have millisecond precision
    int nano1 = ((int) t1.getTime () % 1000) * 1000000;
    // If the parameter is a Timestamp, we have additional precision in nanoseconds
    if (t1 instanceof Timestamp)
        nano1 = ((Timestamp)t1).getNanos ();
    int nano2 = ((int) t2.getTime () % 1000) * 1000000;
    if (t2 instanceof Timestamp)
        nano2 = ((Timestamp)t2).getNanos ();

    int diffNanos = nano1 - nano2;
    if (diffNanos < 0)
    {
        // Borrow one second
        diffSeconds --;
        diffNanos += 1000000000;
    }

    // mix nanos and millis again
    Timestamp result = new Timestamp ((diffSeconds * 1000) + (diffNanos / 1000000));
    // setNanos() with a value of in the millisecond range doesn't affect the value of the time field
    // while milliseconds in the time field will modify nanos! Damn, this API is a *mess*
    result.setNanos (diffNanos);
    return result;
}

单元测试:

    Timestamp t1 = new Timestamp (0);
    Timestamp t3 = new Timestamp (999);
    Timestamp t4 = new Timestamp (5001);
    // Careful here; internally, Java has set nanos already!
    t4.setNanos (t4.getNanos () + 1);

    // Show what a mess this API is...
    // Yes, the milliseconds show up in *both* fields! Isn't that fun?
    assertEquals (999, t3.getTime ());
    assertEquals (999000000, t3.getNanos ());
    // This looks weird but t4 contains 5 seconds, 1 milli, 1 nano.
    // The lone milli is in both results ...
    assertEquals (5001, t4.getTime ());
    assertEquals (1000001, t4.getNanos ());

    diff = DBUtil.diff (t1, t4);
    assertEquals (5001, diff.getTime ());
    assertEquals (1000001, diff.getNanos ());

    diff = DBUtil.diff (t4, t3);
    assertEquals (4002, diff.getTime ());
    assertEquals (2000001, diff.getNanos ());

我使用这种方法来获得2之间的差异 java.sql.Timestmap

/**
 * Get a diff between two timestamps.
 *
 * @param oldTs The older timestamp
 * @param newTs The newer timestamp
 * @param timeUnit The unit in which you want the diff
 * @return The diff value, in the provided time unit.
 */
public static long getDateDiff(Timestamp oldTs, Timestamp newTs, TimeUnit timeUnit) {
    long diffInMS = newTs.getTime() - oldTs.getTime();
    return timeUnit.convert(diffInMS, TimeUnit.MILLISECONDS);
}

// Examples:
// long diffMinutes = getDateDiff(oldTs, newTs, TimeUnit.MINUTES);
// long diffHours = getDateDiff(oldTs, newTs, TimeUnit.HOURS);

在哪些单位?上面的diff将给出毫秒,Timestamp.nanos()返回一个int,其单位为(百万分之一?)毫秒。你是说,例如。

(t1.getTime () + (.000001*t1.getNanos()) - (t2.getTime () + (.000001*t2.getNanos())

基于mmyers代码构建。..

import java.math.BigInteger;
import java.sql.Timestamp;


public class Main
{
    // 1s == 1000ms == 1,000,000us == 1,000,000,000ns (1 billion ns)
    public final static BigInteger ONE_BILLION = new BigInteger ("1000000000");
    public static void main(String[] args) throws InterruptedException 
    {
        final Timestamp t1;
        final Timestamp t2;
        final BigInteger firstTime;
        final BigInteger secondTime;
        final BigInteger diffTime;

        t1 = new Timestamp(System.currentTimeMillis());
        Thread.sleep(20);
        t2 = new Timestamp(System.currentTimeMillis());

        System.out.println(t1);
        System.out.println(t2);
        firstTime  = BigInteger.valueOf(t1.getTime() / 1000 * 1000).multiply(ONE_BILLION ).add(BigInteger.valueOf(t1.getNanos()));
        secondTime = BigInteger.valueOf(t2.getTime() / 1000 * 1000).multiply(ONE_BILLION ).add(BigInteger.valueOf(t2.getNanos()));
        diffTime   = firstTime.subtract(secondTime);
        System.out.println(firstTime);
        System.out.println(secondTime);
        System.out.println(diffTime);
    }
}

编辑2: 新代码:

public class ArraySizeTest {
    public static void main(String[] args) throws InterruptedException {
        Timestamp t1 = new Timestamp(System.currentTimeMillis());
        t1.setNanos(t1.getNanos() + 60);
        Thread.sleep(20);
        Timestamp t2 = new Timestamp(System.currentTimeMillis());
        t2.setNanos(t2.getNanos() + 30);
        System.out.println(t1);
        System.out.println(t2);
        // The actual diff...
        long firstTime = (getTimeNoMillis(t1) * 1000000) + t1.getNanos();
        long secondTime = (getTimeNoMillis(t2) * 1000000) + t2.getNanos();
        long diff = Math.abs(firstTime - secondTime); // diff is in nanos
        System.out.println(diff);
        System.out.println(Math.abs(t1.getTime() - t2.getTime()));
    }
    private static long getTimeNoMillis(Timestamp t) {
        return t.getTime() - (t.getNanos()/1000000);
    }
}

输出:

2009-02-24 10:35:15.56500006
2009-02-24 10:35:15.59600003
30999970
31

如果你更喜欢返回时间戳的东西,请使用以下命令:

public static Timestamp diff(Timestamp t1, Timestamp t2) {
    long firstTime = (getTimeNoMillis(t1) * 1000000) + t1.getNanos();
    long secondTime = (getTimeNoMillis(t2) * 1000000) + t2.getNanos();
    long diff = Math.abs(firstTime - secondTime); // diff is in nanoseconds
    Timestamp ret = new Timestamp(diff / 1000000);
    ret.setNanos((int) (diff % 1000000000));
    return ret;
}
private static long getTimeNoMillis(Timestamp t) {
    return t.getTime() - (t.getNanos()/1000000);
}

此代码通过了您的单元测试。