Win32 FILETIME 结构与 java.util.Dat

MSDN 上关于 FILETIME 结构的描述，可以很方便地在 FILETIME 与 Java 中 Date 进行互转。根据 MSDN 上的描述，FILETIME 采用 64 位数值表示与 UTC 时间 1601 年 1 月 1 日 0 时起百纳秒的时间间隔。

MSDN 上的描述，FILETIME 的结构如下：

typedef struct _FILETIME {  
    DWORD dwLowDateTime;  
    DWORD dwHighDateTime;  
} FILETIME, *PFILETIME;  

由于 DWORD 是 windows.h 中定义数据类型，表示 32 位无符号整数的 unsigned long 类型，因此要需要使用两个 DWORD 才能表示 file time。dwLowDateTime 是指 file time 的低 32 位值，而 dwHighDateTime 是指 file time 的高 32 位值。

在 Java 中的时间是采用 Unix 纪元，即与 UTC 时间 1970 年 1 月 1 日 0 时起的毫秒时间间隔，在 Java 中是使用 long 类型来表示这个值的。

有了上面的知识点，就可以很容易地把 Win32 FileTime 时间与 Java 中 Date 进行互相转换。需要做的是计算出 1601 年 1 月 1 日 0 时与 1970 年 1 月 1 日 0 时之间的毫秒数差值，再加上 Unix 纪元的毫秒数时间，再将其换算成百纳秒就可以进行转换了。按 Unix 纪元 1970 年 1 月 1 日 0 时之前均为负数。

由于涉及时间计算，为了保证正确性，先用代码来校验一下时区，看看 1970 年 1 月 1 日 0 时是否为 0。

import java.text.DateFormat;  
import java.text.ParseException;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
  
public class Test5 {  
  
    public static void main(String[] args) {  
        DateFormat format = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );  
        Date date = parseDate( "1970-01-01 00:00:00", format );  
        System.out.println( date.getTime() );  
    }  
      
    public static Date parseDate(String str, DateFormat format) {  
        Date date = null;  
        try {  
            date = format.parse( str );  
        }
        catch (ParseException e) {  
            e.printStackTrace();  
        }  
        return date;  
    }  
}  

上面代码运行的结果是：

-28800000

可见这个结果是不正确的，由于我们当前系统的时区是 GMT+8 区，也就是比格林尼治标准时间相差 8 个小时，这 28800000 也正好是 8 个小时的毫秒数。我们只要为 DateFormat 加上下面这一段代码就可以将格式化器转为 GMT 时间（对于本文而言 UTC 时间与 GMT 时间没有区别，具体的区别可以参考其他资料）。

public static void main(String[] args) {
    DateFormat format = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
    format.setTimeZone( TimeZone.getTimeZone("UTC") );
    Date date = parseDate( "1970-01-01 00:00:00", format );
    System.out.println( date.getTime() );
}

此时我们输出的结果就是 0 了，再将其换成“1601-01-01 00:00:00”时输出为：

-11644473600000

由于这个值是个常量固定值，将这个值取绝对值暂且命名为UNIX_FILETIME_MILLISECOND_DIFF。

接下来需要获得毫秒数与百纳秒数的倍率。众所周知，1 秒等于 10³ 毫秒，而 1 毫秒等于 10⁶ 纳秒，因此 1 毫秒等于 10⁴ 百纳秒。

由于 FILETIME 结构是采用两个 DWORD 来表示的，由于 DWORD 是无符号 32 位整数，在 Java 中没有对应类型，因此将 DWORD 映射为 long 类型。通过移位运算符 << 可以将这两个 32 位的 long 转换为 64 位的 long 数据，以便于对 Unix 纪元毫秒数的计算。

为了采用面向对象的方式进行设计，可以仿照 FILETIME 结构的定义，声明一个 FILETIME 的类，其中包含高 32 位数字和低 32 位数字。为了封装一下，把 Unix 纪元与 FILETIME 零起点的毫秒值与毫秒与百纳秒的倍率置为常量。

public class FileTime {

    /**
     * Unix 时间 1970-01-01 00:00:00 与 Win32 FileTime 时间 1601-01-01 00:00:00
     * 毫秒数差
     */
    public final static long UNIX_FILETIME_MILLISECOND_DIFF = 11644473600000L;

    /**
     * Win32 FileTime 采用 100ns 为单位的，定义 100 ns 与 1 ms 的倍率
     */
    public final static int MILLISECOND_100NANOSECOND_MULTIPLE = 10000;

    /**
     * FileTime 的低 32 位数
     */
    private final long low;

    /**
     * FileTime 的高 32 位数
     */
    private final long high;

    public FileTime(long high, long low) {
        this.high = high;
        this.low = low;
    }

    /**
     * 获得 FileTime 以 64 位数字表示的数据
     * @return FileTime 的数据值
     */
    public long getFileTime() {
        return ((high << 32) & 0xffffffff00000000L) | (low & 0xffffffffL);
    }

    public long getLow() {
        return low;
    }

    public long getHigh() {
        return high;
    }

    @Override
    public String toString() {
        return "high: " + high + ", low: " + low;
    }
}

定义好了结构，为了能与 java.util.Date 互转，还需要增加一个 toDate 的方法和一个 date2FileTime 的静态方法。

/**
 * 将 Win32 的 FileTime 结构转为 Java 中的 Date 类型
 * @param fileTime
 * @return
 */
public Date toDate() {
    return new Date(getFileTime() / MILLISECOND_100NANOSECOND_MULTIPLE -
            UNIX_FILETIME_MILLISECOND_DIFF);
}

/**
 * 将 Java 中的 Date 类型转为 Win32 的 FileTime 结构
 * @param date
 * @return
 */
public static FileTime date2FileTime(Date date) {
    long time = (UNIX_FILETIME_MILLISECOND_DIFF + date.getTime()) *
            MILLISECOND_100NANOSECOND_MULTIPLE;
    long high = (time >> 32) & 0xffffffffL;
    long low = time & 0xffffffffL;
    FileTime fileTime = new FileTime( high, low );
    return fileTime;
}

结构和代码都定义完成了，写个测试代码来测试一下，看看当前时间的 FileTime 值是多少：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
  
    public static void main(String[] args) {
          
        Date date1 = new Date();

        FileTime fileTime = FileTime.date2FileTime(date1);
        System.out.println(fileTime.toString());

        FileTime fileTile = new FileTime( fileTime.getHigh(), fileTime.getLow() );
        Date date2 = fileTile.toDate();
        System.out.printf( "%tF %<tT%n", date2 );
    }  
      
    public static Date parseDate(String str, DateFormat format) {  
        Date date = null;  
        try {  
            date = format.parse(str);  
        }
        catch (ParseException e) {  
            e.printStackTrace();  
        }  
        return date;  
    }  
} 

更多阅读

• 在 MSDN 上可以找到更多关于 FILETIME 结构的描述
• 在中文维基百科上可以找到 协调世界时（UTC） 与 格林尼治标准时间（GMT） 的相关资料