java如何保存时间到文件，如何计算时间差

Question

初学，有些概念不清楚，请教一下1、java中时间保存是否用Date数据结构？获取当前时间用Date.getTime()和Date.toString()是否可以？2、Date的基类是什么，是long吗？？如何计算两个Date之间相差的秒数？Date1-Date2 ????3，现有一个时间列表Date[] aobjDate=new Date(1000)需要保存到文件，使用时再从文件读出到列表，这个要如何实现？？

Answer 1

1.new java.util.Date().tolocaleString()获取当前时间；
2.应当把Date的类型转换为String类型，保存在数据库中，然后进行减法运算；
3.？

Answer 2

建议使用java.util.Calendar类，
java.util.Calendar.getInstance().getTimeInMillis();返回此 Calendar 的时间值，以毫秒为单位。

Answer 3

如果不是数据库，是特定的文件，可以直接保存Date，当然也可以转换为String再写到文件中，从文件读刚好反过来，与写文件对应，用相反的方法就可以了

Answer 4

用Date.getTime()这个就好了
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数
方便计算

Answer 5

1.可用Date或Calendar,如果你要获得当前时间的毫秒值可直接用System.currentTimeMillis(),要返回"yyyy-MM-dd hh:mm:ss"格式化的日期形式可用SimpleDateFormat对Date类型的进行格式化.2.Date是继承自Ojbect的,计算两个Date类型的对象之间的时间差可用Date first = new Date();
Date second = new Date();
long result = first.getTime()-second.getTime();
3.请LZ把问题描述清楚些...

Answer 6

1.还是用Calendar类比较好,因为它比较国际化Calendar cl=Calendar.getInstends();//获取当前日期
System.out.println(cl.get(cl.YEAR)+"-"+cl.get(cl.MONTH+1)+"-"+cl.get(cl.DAY));//可以这样输出2.Date是继承自Object的，是long型的Date d1 = new Date();
Date d2 = new Date();
long d = d1.getTime()-d2.getTime();3.米有看懂

Answer 7

关于问题3有一个时间列表objDatA[1000]，内容假设为
19003－3－4 xx:xx:xx
19003－4－4 xx:xx:xx
19003－5－4 xx:xx:xx
19003－3－6 xx:xx:xx
19003－3－7 xx:xx:xx
....我要把它写到一个文件，或者InputStream里然后再读到objDatB[1000]中
这个如何做呢?

Answer 8

主要是我不知道java的byte[]和long转换方式，在顺序储存到byte[]和，顺序读取byte[]到Date[]不会做

Answer 9

比方说，java的数据类型是类，我不知道long转换为byte占用几个byte位。因为java运行在虚拟机上，要是在long上是4位，到mobi上变成2位，转换就要错误

Answer 10

无论是何种平台上的 Java，long 数据类型的数值范围都是使用 64 位
的有符号数，也就是说不管是 32 位系统还是 64 位系统，都是这样规
定的。至于其在内存中具体占多少个字节 Java 开发人员不用去关心。至于要让 long 转成 byte 数组，这得看具体采用 Big-Endian 方式，
还是 Little-Encdian 方式了。public class Main {
    
    public static void main(String[] args) throws IOException {
        long k = 0xcafebabeL;
        System.out.println("数字:\t\t\t" + k);
        System.out.println("位值:\t\t\t" + NumberUtil.toFullBinaryString(k));
        
        // BE 方式转为 byte 数组
        byte[] bys = ByteUtil.long2BytesBE(k);
        System.out.println("BE byte 值:\t\t" + ByteUtil.bytes2Hex(bys));
        System.out.println("BE byte 转为 long:\t" + ByteUtil.bytes2LongBE(bys));        // LE 方式转为 byte 数组
        bys = ByteUtil.long2BytesLE(k);
        System.out.println("LE byte 值:\t\t" + ByteUtil.bytes2Hex(bys));
        System.out.println("LE byte 转为 long:\t" + ByteUtil.bytes2LongLE(bys));       
    }
}public class NumberUtil {
    
    /**
     * 将 long 类型数据转成二进制的字符串，不足 long 类型位数时在前面添“0”以凑足位数
     * @param num
     * @return
     */
    public static String toFullBinaryString(long num) {
        char[] chs = new char[Long.SIZE];
        for(int i = 0; i < Long.SIZE; i++) {
            chs[Long.SIZE - 1 - i] = (char)(((num >> i) & 1) + '0');
        }
        return new String(chs);        
    }
}public class ByteUtil {    private final static char[] HEX = "0123456789abcdef".toCharArray();         /**
     * 将字节数组转成 16 进制的字符串来表示，每个字节采用两个字符表表示，
     * 每个字节间采用一个空格分隔
     * @param bys       需要转换成 16 进制的字节数组
     * @return
     */
    public static String bytes2HexSpace(byte[] bys) {
        char[] chs = new char[bys.length * 2 + bys.length - 1];
        for(int i = 0, offset = 0; i < bys.length; i++) {
            if(i > 0) {
                chs[offset++] = ' ';
            }
            chs[offset++] = HEX[bys[i] >> 4 & 0xf];
            chs[offset++] = HEX[bys[i] & 0xf];
        }
        return new String(chs);
    }    /**
     * 将字节数组转成 16 进制的字符串来表示，每个字节采用两个字符表表示
     * 
     * @param bys       需要转换成 16 进制的字节数组
     * @return
     */
    public static String bytes2Hex(byte[] bys) {
        char[] chs = new char[bys.length * 2];
        for(int i = 0, offset = 0; i < bys.length; i++) {
            chs[offset++] = HEX[bys[i] >> 4 & 0xf];
            chs[offset++] = HEX[bys[i] & 0xf];
        }
        return new String(chs);
    }    /**
     * 采用 Big-Endian 方式将 long 数据转为 byte 数组
     * 
     * @param num
     * @return  转为 Big-Endian 方式的 byte 数组 
     */
    public static byte[] long2BytesBE(long num) {
        byte[] bys = new byte[Long.SIZE / Byte.SIZE];
        for(int i = 0, k = bys.length; i < k; i++) {
            bys[i] = (byte)(num >>> ((k - 1 - i) * Byte.SIZE) & 0xff);
        }
        return bys;
    }    /**
     * 采用 Little-Endian 方式将 long 数据转为 byte 数组
     * 
     * @param num
     * @return  转为 Little-Endian 方式的 byte 数组 
     */
    public static byte[] long2BytesLE(long num) {        
        return long2BytesBE(Long.reverseBytes(num));
    }    /**
     * 将 Little-Endian 的字符数组转为 long 类型的数据<br />
     * Little-Endian 表示高位字节在低位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 LE 方式表示的 long 数值
     */
    public static long bytes2LongLE(byte[] bys, int start, int len) {
        return bytes2Long(bys, start, len, false);
    }    public static long bytes2LongLE(byte[] bys) {
        return bytes2Long(bys, 0, bys.length, false);
    }    /**
     * 将 Big-Endian 的字符数组转为 long 类型的数据<br />
     * Big-Endian 表示高位字节在高位索引中
     * @param bys       字节数组
     * @param start     需要转换的开始索引位数
     * @param len       需要转换的字节数量
     * @return  指定开始位置和长度以 BE 方式表示的 long 数值
     */
    public static long bytes2LongBE(byte[] bys, int start, int len) {
        return bytes2Long(bys, start, len, true);
    }    public static long bytes2LongBE(byte[] bys) {
        return bytes2Long(bys, 0, bys.length, true);
    }    private static long bytes2Long(byte[] bys, int start, int len, 
            boolean isBigEndian) {
        long n = 0L;
        for(int i = start, k = start + len % (Long.SIZE / Byte.SIZE + 1); i < k; i++) {
            n += (bys[i] & 0xffL) << ((isBigEndian ? (k - i - 1) : i) * Byte.SIZE);
        }
        return n;
    }
}

Answer 11

Date的基类是什么，
Date的基类你可以看api啊如何计算两个Date之间相差的秒数？Date1-Date2 ???? 
data里面有方法把 计算2个时间的差、