我想要这样的东西：
public class Stream
{
public startTime;
public endTime;
public getDuration()
{
return startTime - endTime;
}
}
同样重要的是，例如，如果 startTime 是 23:00，endTime 是 1:00，则持续时间为 2:00。
在 Java 中使用哪些类型来完成此任务？
【问题讨论】：
System.nanoTime()。这里的这个问题的重点是计算两个时刻之间的经过时间，而不考虑获取当前时间。
如果您从 System.currentTimeMillis() 获取时间戳，那么您的时间变量应该是 longs。
【讨论】：
Java 提供了静态方法System.currentTimeMillis()。这会返回一个长值，所以它是一个很好的参考。许多其他类也接受一个很长的“timeInMillis”参数。
而且很多人发现使用Joda Time 库来计算日期和时间更容易。
【讨论】：
你的新班级：
public class TimeWatch {
long starts;
public static TimeWatch start() {
return new TimeWatch();
}
private TimeWatch() {
reset();
}
public TimeWatch reset() {
starts = System.currentTimeMillis();
return this;
}
public long time() {
long ends = System.currentTimeMillis();
return ends - starts;
}
public long time(TimeUnit unit) {
return unit.convert(time(), TimeUnit.MILLISECONDS);
}
}
用法：
TimeWatch watch = TimeWatch.start();
// do something
long passedTimeInMs = watch.time();
long passedTimeInSeconds = watch.time(TimeUnit.SECONDS);
之后，可以将经过的时间转换为您喜欢的任何格式，例如使用日历
问候， 加德
【讨论】：
TimeUnit 提及。我不知道它存在（为什么它不在 `java.util' 包中？）
如果你更喜欢使用 Java 的 Calendar API，你可以试试这个，
Date startingTime = Calendar.getInstance().getTime();
//later on
Date now = Calendar.getInstance().getTime();
long timeElapsed = now.getTime() - startingTime.getTime();
【讨论】：
System.currentTimeMillis()，您无需了解时区以及您在Calendar#toString() 中看到的所有内容。
在 Java 中使用哪些类型来完成此任务？
答案：长
public class Stream {
public long startTime;
public long endTime;
public long getDuration() {
return endTime - startTime;
}
// I would add
public void start() {
startTime = System.currentTimeMillis();
}
public void stop() {
endTime = System.currentTimeMillis();
}
}
用法：
Stream s = ....
s.start();
// do something for a while
s.stop();
s.getDuration(); // gives the elapsed time in milliseconds.
这是我对您的第一个问题的直接回答。
对于最后一个“注释”，我建议您使用 Joda Time。它包含一个适合您需要的interval 类。
【讨论】：
在 Java 中使用哪些类型来完成此任务？
简短的回答是long。现在，更多关于如何测量...
“传统”的做法确实是使用System.currentTimeMillis()：
long startTime = System.currentTimeMillis();
// ... do something ...
long estimatedTime = System.currentTimeMillis() - startTime;
请注意，Commons Lang 有一个 StopWatch 类，可用于测量执行时间（以毫秒为单位）。它具有split()、suspend()、resume() 等方法方法，允许在执行的不同点进行测量，您可能会觉得方便。看看吧。
如果您正在寻找经过时间的极其精确的测量值，您可能更喜欢使用System.nanoTime()。从它的javadoc：
long startTime = System.nanoTime();
// ... the code being measured ...
long estimatedTime = System.nanoTime() - startTime;
另一种选择是使用JAMon，这是一个收集统计数据（执行时间、命中次数、平均执行时间、最小值、最大值等）的工具，用于在开始之间的任何代码() 和 stop() 方法。下面，一个非常简单的例子：
import com.jamonapi.*;
...
Monitor mon=MonitorFactory.start("myFirstMonitor");
...Code Being Timed...
mon.stop();
查看 www.javaperformancetunning.com 上的 this article 以获得很好的介绍。
最后，如果您不想通过这些度量来弄乱您的代码（或者如果您无法更改现有代码），那么 AOP 将是一个完美的武器。我不会深入讨论这个问题，但我至少想提一下。
下面是一个使用 AspectJ 和 JAMon 的非常简单的切面（这里，切入点的简称将用于 JAMon 监视器，因此调用thisJoinPoint.toShortString()）：
public aspect MonitorAspect {
pointcut monitor() : execution(* *.ClassToMonitor.methodToMonitor(..));
Object arround() : monitor() {
Monitor monitor = MonitorFactory.start(thisJoinPoint.toShortString());
Object returnedObject = proceed();
monitor.stop();
return returnedObject;
}
}
切入点定义可以很容易地适应基于类名、包名、方法名或这些的任何组合来监视任何方法。测量确实是 AOP 的完美用例。
【讨论】：
如果您正在编写一个必须处理持续时间的应用程序，那么请查看 Joda-Time，它具有专门用于处理持续时间、Intervals 和期间的类。您的 getDuration() 方法看起来可以返回 Joda-Time Interval：
DateTime start = new DateTime(2004, 12, 25, 0, 0, 0, 0);
DateTime end = new DateTime(2005, 1, 1, 0, 0, 0, 0);
public Interval getInterval() {
Interval interval = new Interval(start, end);
}
【讨论】：
如果目的只是将粗略的计时信息打印到程序日志中，那么 Java 项目的简单解决方案不是编写自己的秒表或计时器类，而只需使用 Apache Commons 中的 org.apache.commons.lang.time.StopWatch 类朗。
final StopWatch stopwatch = new StopWatch();
stopwatch.start();
LOGGER.debug("Starting long calculations: {}", stopwatch);
...
LOGGER.debug("Time after key part of calcuation: {}", stopwatch);
...
LOGGER.debug("Finished calculating {}", stopwatch);
【讨论】：
System.currentTimeMillis() 仅适用于 getStartTime() 属性。时间计算完全基于System.nanoTime()（至少在org.apache.commons.lang3版本中）
值得注意的是
【讨论】：
很遗憾，到目前为止发布的十个答案中没有一个是完全正确的。
如果您正在测量经过的时间，并且希望它正确，则必须使用System.nanoTime()。你不能使用System.currentTimeMillis()，除非你不介意你的结果是错误的。
nanoTime 的目的是测量经过时间，currentTimeMillis 的目的是测量挂钟时间。您不能将其中一个用于其他目的。原因是没有计算机的时钟是完美的。它总是漂移，偶尔需要纠正。这种更正可能是手动进行的，或者在大多数机器的情况下，有一个进程在运行并不断地对系统时钟（“挂钟”）进行小幅更正。这些往往会经常发生。每当有闰秒时，就会发生另一种这样的修正。
由于nanoTime 的目的是测量经过的时间，它不受任何这些小修正的影响。这是你想要使用的。当前与currentTimeMillis 进行的任何时间安排都将被取消——甚至可能是负面的。
您可能会说，“这听起来好像并没有那么重要”，我说，也许不是，但总的来说，正确的代码不比不正确的代码更好吗？此外，nanoTime 无论如何都更短。
之前发布的关于nanoTime 通常只有微秒精度的免责声明是有效的。此外，调用可能需要超过一微秒的时间，具体取决于具体情况（其他情况也是如此），因此不要期望正确计时非常小的时间间隔。
【讨论】：
TimeUnit.NANOSECONDS.toMillis(value)。
例如，如果 startTime 为 23:00，endTime 为 1:00，则持续时间为 2:00。
不可能。如果您只有一天中的时间，则时钟会在午夜停止。如果没有日期的上下文，我们怎么知道您是指第二天、下周还是下一个十年的凌晨 1 点？
因此，从晚上 11 点到凌晨 1 点意味着时间向后移动 22 小时，逆时针转动时钟的指针。请参阅下面的结果，否定 22 小时。
Duration.between( // Represent a span of time a total number of seconds plus a fractional second in nanoseconds.
LocalTime.of( 23 , 0 ) , // A time-of-day without a date and without a time zone.
LocalTime.of( 1 , 0 ) // A time-of-day clock stops at midnight. So getting to 1 AM from 11 PM means going backwards 22 hours.
) // Return a `Duration` object.
.toString() // Generate a `String` representing this span of time using standard ISO 8601 format: PnYnMnDTnHnMnS
PT-22H
除了时间之外，跨越午夜还需要更大的日期上下文（见下文）。
如何在 Java 中测量经过的时间？
Instant.now() 捕捉UTC 中的当前时刻。Duration.between。Duration 对象中，通过调用各种 to…Part 方法，提取 24 小时天数、小时、分钟、秒和小数秒（以纳秒为单位）。toString 在standard ISO 8601 format 的PnYnMnDTnHnMnS 中生成一个String。示例代码，使用一对 Instant 对象。
Duration.between( // Represent a span of time a total number of seconds plus a fractional second in nanoseconds.
then , // Some other `Instant` object, captured earlier with `Instant.now()`.
Instant.now() // Capture the current moment in UTC with a resolution as fine as nanoseconds, depending on the limits of your host computer hardware clock and operating system. Generally you will get current moment in microseconds (six decimal digits of fractional second) in Java 9, 10, and 11, but only milliseconds in Java 8.
) // Return a `Duration` object.
.toString() // Generate a `String` representing this span of time using standard ISO 8601 format: PnYnMnDTnHnMnS
PT3M27.602197S
我们现在在 Java 8 及更高版本中内置了这方面的新技术，java.time 框架。
java.time 框架由JSR 310 定义，灵感来自非常成功的Joda-Time 项目，由ThreeTen-Extra 项目扩展，并在Oracle Tutorial 中进行了描述。
Java.util.Date/.Calendar 等旧的日期时间类与 Java 的最早版本捆绑在一起，已被证明设计不佳、令人困惑和麻烦。它们被 java.time 类所取代。
其他答案讨论解决方案。
java.time 类具有nanosecond 分辨率，最多为一秒的十进制小数的九位。例如，2016-03-12T04:29:39.123456789Z。
旧的 java.util.Date/.Calendar 类和 Joda-Time 类都具有毫秒分辨率（3 位小数）。例如，2016-03-12T04:29:39.123Z。
在 Java 8 中，由于遗留问题，当前时刻的获取分辨率最高仅为毫秒。在 Java 9 及更高版本中，如果您的计算机的硬件时钟运行良好，则当前时间可以被确定为纳秒级分辨率。
如果您真的只想使用缺少任何日期或时区的时间，请使用 LocalTime 类。
LocalTime sooner = LocalTime.of ( 17, 00 );
LocalTime later = LocalTime.of ( 19, 00 );
Duration 表示时间跨度，它以秒数加上纳秒数表示。
Duration duration = Duration.between ( sooner, later );
转储到控制台。
System.out.println ( "sooner: " + sooner + " | later: " + later + " | duration: " + duration );
较早：17:00 |稍后：19:00 |持续时间：PT2H
注意Duration::toString 的默认输出是标准ISO 8601 格式。在这种格式中，P 标志着开始（如“期间”），T 将任何年-月-日部分与小时-分钟-秒部分分开。
不幸的是，只有当您绕着时钟穿过午夜时，处理时间才会变得棘手。 LocalTime 类通过假设您想回到当天的早些时候来处理这个问题。
使用与上述相同的代码，但从 23:00 变为 01:00 会导致负 22 小时 (PT-22H)。
LocalTime sooner = LocalTime.of ( 23, 0 );
LocalTime later = LocalTime.of ( 1, 0 );
更早：23:00 |稍后：01:00 |持续时间：PT-22H
如果您打算跨过午夜，那么使用日期时间值而不是仅时间值可能对您来说是有意义的。
时区对于日期至关重要。因此，我们指定了三个项目：(1) 所需日期，(2) 所需时间，以及 (3) 时区作为解释该日期和时间的上下文。这里我们随意选择Montréal区域的时区。
如果您仅通过 offset-from-UTC 定义日期，请使用 ZoneOffset 和 OffsetDateTime。如果您有一个完整的时区（偏移量加上处理异常情况的规则，例如夏令时），请使用 ZoneId 和 ZonedDateTime。
LocalDate localDate = LocalDate.of ( 2016, 1, 23 );
ZoneId zoneId = ZoneId.of ( "America/Montreal" );
ZonedDateTime sooner = ZonedDateTime.of ( localDate, LocalTime.of ( 23, 0 ), zoneId );
我们指定较晚的时间为第二天凌晨 1:00。
ZonedDateTime later = ZonedDateTime.of ( localDate.plusDays ( 1 ), LocalTime.of ( 1, 0 ), zoneId );
我们以与上述相同的方式计算Duration。现在我们得到了这个问题所期望的两个小时。
Duration duration = Duration.between ( sooner, later );
转储到控制台。
System.out.println ( "sooner: " + sooner + " | later: " + later + " | duration: " + duration );
较早：2016-01-23T23:00-05:00[美国/蒙特利尔] |稍后：2016-01-24T01:00-05:00[美国/蒙特利尔] |持续时间：PT2H
如果手头的日期时间涉及夏令时 (DST) 或其他此类异常，java.time 类将根据需要进行调整。阅读课程文档了解详情。
java.time 框架内置于 Java 8 及更高版本中。这些类取代了麻烦的旧 legacy 日期时间类，例如 java.util.Date、Calendar 和 SimpleDateFormat。
Joda-Time 项目现在位于maintenance mode，建议迁移到java.time 类。
要了解更多信息，请参阅Oracle Tutorial。并在 Stack Overflow 上搜索许多示例和解释。规格为JSR 310。
您可以直接与您的数据库交换 java.time 对象。使用符合JDBC 4.2 或更高版本的JDBC driver。不需要字符串，不需要java.sql.* 类。
从哪里获得 java.time 类？
ThreeTen-Extra 项目通过附加类扩展了 java.time。该项目是未来可能添加到 java.time 的试验场。您可以在这里找到一些有用的类，例如Interval、YearWeek、YearQuarter 和more。
【讨论】：
Duration，也没有解释诸如夏令时被仅时间计算忽略的异常情况。至于不在这里解决问题，我会说Duration.between ( sooner, later ) 结合对午夜滚动问题的解释是对询问“如果 startTime 是 23:00 和 endTime 1:00 来获得持续时间的现场回答2:00”。虽然我很欣赏建设性的批评，但我期待更多的努力。
我发现这段代码在计时时很有用：
public class Et {
public Et() {
reset();
}
public void reset() {
t0=System.nanoTime();
}
public long t0() {
return t0;
}
public long dt() {
return System.nanoTime()-t0();
}
public double etms() {
return etms(dt());
}
@Override public String toString() {
return etms()+" ms.";
}
public static double etms(long dt) {
return dt/1000000.; // 1_000_000. breaks cobertura
}
private Long t0;
}
【讨论】：
使用这个：
SimpleDateFormat format = new SimpleDateFormat("HH:mm");
Date d1 = format.parse(strStartTime);
Date d2 = format.parse(strEndTime);
long diff = d2.getTime() - d1.getTime();
long diffSeconds,diffMinutes,diffHours;
if (diff > 0) {
diffSeconds = diff / 1000 % 60;
diffMinutes = diff / (60 * 1000) % 60;
diffHours = diff / (60 * 60 * 1000);
}
else{
long diffpos = (24*((60 * 60 * 1000))) + diff;
diffSeconds = diffpos / 1000 % 60;
diffMinutes = diffpos / (60 * 1000) % 60;
diffHours = (diffpos / (60 * 60 * 1000));
}
（同样重要的是，例如，如果 startTime 为 23:00，endTime 为 1:00，则持续时间为 2:00。）
“else”部分可以正确处理
【讨论】：
Byte Stream Reader Elapsed Time for 23.7 MB is 96 secs
import java.io.*;
import java.io.IOException;
import java.util.Scanner;
class ElaspedTimetoCopyAFileUsingByteStream
{
private long startTime = 0;
private long stopTime = 0;
private boolean running = false;
public void start()
{
this.startTime = System.currentTimeMillis();
this.running = true;
}
public void stop()
{
this.stopTime = System.currentTimeMillis();
this.running = false;
}
public long getElapsedTime()
{
long elapsed;
if (running) {
elapsed = (System.currentTimeMillis() - startTime);
}
else {
elapsed = (stopTime - startTime);
}
return elapsed;
}
public long getElapsedTimeSecs()
{
long elapsed;
if (running)
{
elapsed = ((System.currentTimeMillis() - startTime) / 1000);
}
else
{
elapsed = ((stopTime - startTime) / 1000);
}
return elapsed;
}
public static void main(String[] args) throws IOException
{
ElaspedTimetoCopyAFileUsingByteStream s = new ElaspedTimetoCopyAFileUsingByteStream();
s.start();
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("vowels.txt"); // 23.7 MB File
out = new FileOutputStream("output.txt");
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
s.stop();
System.out.println("elapsed time in seconds: " + s.getElapsedTimeSecs());
}
}
[Elapsed Time for Byte Stream Reader][1]
**Character Stream Reader Elapsed Time for 23.7 MB is 3 secs**
import java.io.*;
import java.io.IOException;
import java.util.Scanner;
class ElaspedTimetoCopyAFileUsingCharacterStream
{
private long startTime = 0;
private long stopTime = 0;
private boolean running = false;
public void start()
{
this.startTime = System.currentTimeMillis();
this.running = true;
}
public void stop()
{
this.stopTime = System.currentTimeMillis();
this.running = false;
}
public long getElapsedTime()
{
long elapsed;
if (running) {
elapsed = (System.currentTimeMillis() - startTime);
}
else {
elapsed = (stopTime - startTime);
}
return elapsed;
}
public long getElapsedTimeSecs()
{
long elapsed;
if (running)
{
elapsed = ((System.currentTimeMillis() - startTime) / 1000);
}
else
{
elapsed = ((stopTime - startTime) / 1000);
}
return elapsed;
}
public static void main(String[] args) throws IOException
{
ElaspedTimetoCopyAFileUsingCharacterStream s = new ElaspedTimetoCopyAFileUsingCharacterStream();
s.start();
FileReader in = null; // CharacterStream Reader
FileWriter out = null;
try {
in = new FileReader("vowels.txt"); // 23.7 MB
out = new FileWriter("output.txt");
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
s.stop();
System.out.println("elapsed time in seconds: " + s.getElapsedTimeSecs());
}
}
[Elapsed Time for Character Stream Reader][2]
[1]: https://i.stack.imgur.com/hYo8y.png
[2]: https://i.stack.imgur.com/xPjCK.png
【讨论】：
我根据我偷走的东西构建了一个格式化函数。我需要一种在日志消息中“分析”内容的方法，因此我需要一个固定长度的持续时间消息。
public static String GetElapsed(long aInitialTime, long aEndTime, boolean aIncludeMillis)
{
StringBuffer elapsed = new StringBuffer();
Map<String, Long> units = new HashMap<String, Long>();
long milliseconds = aEndTime - aInitialTime;
long seconds = milliseconds / 1000;
long minutes = milliseconds / (60 * 1000);
long hours = milliseconds / (60 * 60 * 1000);
long days = milliseconds / (24 * 60 * 60 * 1000);
units.put("milliseconds", milliseconds);
units.put("seconds", seconds);
units.put("minutes", minutes);
units.put("hours", hours);
units.put("days", days);
if (days > 0)
{
long leftoverHours = hours % 24;
units.put("hours", leftoverHours);
}
if (hours > 0)
{
long leftoeverMinutes = minutes % 60;
units.put("minutes", leftoeverMinutes);
}
if (minutes > 0)
{
long leftoverSeconds = seconds % 60;
units.put("seconds", leftoverSeconds);
}
if (seconds > 0)
{
long leftoverMilliseconds = milliseconds % 1000;
units.put("milliseconds", leftoverMilliseconds);
}
elapsed.append(PrependZeroIfNeeded(units.get("days")) + " days ")
.append(PrependZeroIfNeeded(units.get("hours")) + " hours ")
.append(PrependZeroIfNeeded(units.get("minutes")) + " minutes ")
.append(PrependZeroIfNeeded(units.get("seconds")) + " seconds ")
.append(PrependZeroIfNeeded(units.get("milliseconds")) + " ms");
return elapsed.toString();
}
private static String PrependZeroIfNeeded(long aValue)
{
return aValue < 10 ? "0" + aValue : Long.toString(aValue);
}
还有一个测试类：
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import junit.framework.TestCase;
public class TimeUtilsTest extends TestCase
{
public void testGetElapsed()
{
long start = System.currentTimeMillis();
GregorianCalendar calendar = (GregorianCalendar) Calendar.getInstance();
calendar.setTime(new Date(start));
calendar.add(Calendar.MILLISECOND, 610);
calendar.add(Calendar.SECOND, 35);
calendar.add(Calendar.MINUTE, 5);
calendar.add(Calendar.DAY_OF_YEAR, 5);
long end = calendar.getTimeInMillis();
assertEquals("05 days 00 hours 05 minutes 35 seconds 610 ms", TimeUtils.GetElapsed(start, end, true));
}
}
【讨论】：