有没有一种快速、低垃圾的方法呢？我不能只做简单的模数运算，因为这不考虑闰秒和其他日期/时间有趣的事情。
问问题
8161 次
6 回答
13
我已经弄清楚了如何在整数算术中处理闰年，并实现了一个从 Epoch 到日期/时间的秒数的转换器（不过，它永远不会给你超过 59 秒的时间）。下面的 C 代码应该很容易移植到 Java。
#include <string.h>
#include <time.h>
typedef unsigned uint;
typedef unsigned long long uint64;
struct tm* SecondsSinceEpochToDateTime(struct tm* pTm, uint64 SecondsSinceEpoch)
{
uint64 sec;
uint quadricentennials, centennials, quadrennials, annuals/*1-ennial?*/;
uint year, leap;
uint yday, hour, min;
uint month, mday, wday;
static const uint daysSinceJan1st[2][13]=
{
{0,31,59,90,120,151,181,212,243,273,304,334,365}, // 365 days, non-leap
{0,31,60,91,121,152,182,213,244,274,305,335,366} // 366 days, leap
};
/*
400 years:
1st hundred, starting immediately after a leap year that's a multiple of 400:
n n n l \
n n n l } 24 times
... /
n n n l /
n n n n
2nd hundred:
n n n l \
n n n l } 24 times
... /
n n n l /
n n n n
3rd hundred:
n n n l \
n n n l } 24 times
... /
n n n l /
n n n n
4th hundred:
n n n l \
n n n l } 24 times
... /
n n n l /
n n n L <- 97'th leap year every 400 years
*/
// Re-bias from 1970 to 1601:
// 1970 - 1601 = 369 = 3*100 + 17*4 + 1 years (incl. 89 leap days) =
// (3*100*(365+24/100) + 17*4*(365+1/4) + 1*365)*24*3600 seconds
sec = SecondsSinceEpoch + 11644473600LL;
wday = (uint)((sec / 86400 + 1) % 7); // day of week
// Remove multiples of 400 years (incl. 97 leap days)
quadricentennials = (uint)(sec / 12622780800ULL); // 400*365.2425*24*3600
sec %= 12622780800ULL;
// Remove multiples of 100 years (incl. 24 leap days), can't be more than 3
// (because multiples of 4*100=400 years (incl. leap days) have been removed)
centennials = (uint)(sec / 3155673600ULL); // 100*(365+24/100)*24*3600
if (centennials > 3)
{
centennials = 3;
}
sec -= centennials * 3155673600ULL;
// Remove multiples of 4 years (incl. 1 leap day), can't be more than 24
// (because multiples of 25*4=100 years (incl. leap days) have been removed)
quadrennials = (uint)(sec / 126230400); // 4*(365+1/4)*24*3600
if (quadrennials > 24)
{
quadrennials = 24;
}
sec -= quadrennials * 126230400ULL;
// Remove multiples of years (incl. 0 leap days), can't be more than 3
// (because multiples of 4 years (incl. leap days) have been removed)
annuals = (uint)(sec / 31536000); // 365*24*3600
if (annuals > 3)
{
annuals = 3;
}
sec -= annuals * 31536000ULL;
// Calculate the year and find out if it's leap
year = 1601 + quadricentennials * 400 + centennials * 100 + quadrennials * 4 + annuals;
leap = !(year % 4) && (year % 100 || !(year % 400));
// Calculate the day of the year and the time
yday = sec / 86400;
sec %= 86400;
hour = sec / 3600;
sec %= 3600;
min = sec / 60;
sec %= 60;
// Calculate the month
for (mday = month = 1; month < 13; month++)
{
if (yday < daysSinceJan1st[leap][month])
{
mday += yday - daysSinceJan1st[leap][month - 1];
break;
}
}
// Fill in C's "struct tm"
memset(pTm, 0, sizeof(*pTm));
pTm->tm_sec = sec; // [0,59]
pTm->tm_min = min; // [0,59]
pTm->tm_hour = hour; // [0,23]
pTm->tm_mday = mday; // [1,31] (day of month)
pTm->tm_mon = month - 1; // [0,11] (month)
pTm->tm_year = year - 1900; // 70+ (year since 1900)
pTm->tm_wday = wday; // [0,6] (day since Sunday AKA day of week)
pTm->tm_yday = yday; // [0,365] (day since January 1st AKA day of year)
pTm->tm_isdst = -1; // daylight saving time flag
return pTm;
}
于 2012-06-25T21:20:50.540 回答
4
我不能只做简单的模数运算，因为这不考虑闰秒和其他日期/时间有趣的事情。
Java一般不考虑闰秒 - 或者更确切地说，这取决于平台，但我不相信它在任何常见的生产平台中实现。你确定你需要考虑闰秒吗？如果这样做，您应该能够对添加或删除的秒数进行简单的基于表的查找，具体取决于您的数据源是什么以及您希望它反映什么。
至于“其他日期/时间有趣的事情” - 我认为这个特定的计算没有任何有趣的事情。例如，时区与自纪元以来经过的时间无关。
于 2012-06-25T11:41:28.017 回答
2
假设“纪元”是指 01-01-1970, 00:00:00 GMT：
long secondsSinceEpoch = ...;
// The constructor of Date expects milliseconds
// since 01-01-1970, 00:00:00 GMT
Date date = new Date(secondsSinceEpoch * 1000L);
DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
System.out.println(df.format(date));
于 2012-06-25T11:41:42.313 回答
1
Calendar = Calendar.getInstance();
calendar.setTimeInMillis(secondsSinceTheEpoch*1000);
于 2012-06-25T11:43:15.877 回答
1
这是一种快速、零垃圾的解决方案。关键是不要Calendar在每次调用时创建一个新的实例，因为它是一个重量级的对象，占用 448 字节的堆空间和几乎一微秒的时间来初始化（Java 6、64 位 HotSpot、OS X）。
HmsCalculator旨在从单个线程中使用（每个线程必须使用不同的实例）。
public class HmsCalculator
{
private final Calendar c = Calendar.getInstance();
public Hms toHms(long t) { return toHms(t, new Hms()); }
public Hms toHms(long t, Hms hms) {
c.setTimeInMillis(t*1000);
return hms.init(c);
}
public static class Hms {
public int h, m, s;
private Hms init(Calendar c) {
h = c.get(HOUR_OF_DAY); m = c.get(MINUTE); s = c.get(SECOND);
return this;
}
public String toString() { return String.format("%02d:%02d:%02d",h,m,s); }
}
public static void main(String[] args) {
System.out.println(new HmsCalculator().toHms(
System.currentTimeMillis()/1000));
}
}
PS我没有粘贴所有那些静态导入（无聊）。
于 2012-06-25T11:49:14.147 回答
0
java.time
从 Java 8 及更高版本开始，要使用的内置类Instant来自java.time框架。
Instant instant = Instant.ofEpochSecond ( 1_469_168_058L );
转储到控制台。
System.out.println ( "instant: " + instant );
瞬间：2016-07-22T06:14:18Z
表现
我不知道在java.time.Instant执行速度或垃圾生产方面的表现如何。但是您应该针对此类进行测试。在我仔细阅读Java 9 中的源代码时，它看起来非常简单和快速。
通过一些方法跳转，它基本上只分配一对整数，（a）从纪元开始的秒数（a 64-bit long）和（b）纳秒计数作为秒的分数（a 32-bit int），在做了几次快速检查后：
首先查找零值，在这种情况下，它会返回纪元本身的静态实例。
if ((seconds | nanoOfSecond) == 0) {
return EPOCH;
}
其次对最小/最大常量对的秒数进行完整性检查。
if (seconds < MIN_SECOND || seconds > MAX_SECOND) {
throw new DateTimeException("Instant exceeds minimum or maximum instant");
}
然后调用构造函数，它将这对整数值分配给一对成员变量（long分别是int基元）。
this.seconds = epochSecond;
this.nanos = nanos;
当然，这只是建筑。询问诸如时间等部分意味着更多的工作。通过toString涉及另一个类 a 的方法生成字符串也是如此DateTimeFormatter。toString源代码是一行。
return DateTimeFormatter.ISO_INSTANT.format(this);
请记住，如果您想要在 UTC 以外的时区中使用诸如年、月、日、小时等部分，这意味着更多的工作涉及ZoneId和ZonedDateTime课程。例如：
ZoneId zoneId = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = instant.atZone( zoneId );
于 2016-07-23T23:39:20.217 回答