К сожалению, ни один из десяти опубликованных ответов не является правильным.

Если вы измеряете прошедшее время и хотите, чтобы оно было правильным, вы должны использовать System.nanoTime(). Вы не можете использовать System.currentTimeMillis(), если не возражаете против неправильного результата.

Цель nanoTime - измерить прошедшее время, а цель currentTimeMillis - измерить время настенных часов. Вы не можете использовать одно для другой цели. Причина в том, что никакие компьютерные часы не идеальны; он всегда дрейфует и время от времени требует исправления. Это исправление может произойти либо вручную, либо, в случае большинства машин, есть процесс, который выполняется и постоянно вносит небольшие исправления в системные часы («настенные часы»). Это часто случается. Еще одна такая коррекция происходит всякий раз, когда есть дополнительная секунда.

Поскольку целью nanoTime является измерение прошедшего времени, на него не влияют никакие из этих небольших поправок. Это то, что вы хотите использовать. Все текущие тайминги с currentTimeMillis будут отключены - возможно, даже отрицательные.

Вы можете сказать: «Не похоже, что это когда-либо будет иметь такое большое значение», на что я скажу, что, может быть, и нет, но в целом, не правильный код просто лучше, чем неправильный код? К тому же nanoTime все равно короче печатать.

Ранее опубликованные заявления об отказе от ответственности о nanoTime, которые обычно имеют точность только в микросекундах, являются действительными. Кроме того, для вызова может потребоваться более целой микросекунды, в зависимости от обстоятельств (как и другие), поэтому не рассчитывайте правильно рассчитывать очень и очень маленькие интервалы.

Какие типы использовать для этого в Java?

Краткий ответ - long. Теперь подробнее о том, как измерить ...

System.currentTimeMillis ()

"Традиционный" способ сделать это действительно - использовать _ 2_:

long startTime = System.currentTimeMillis();
// ... do something ...
long estimatedTime = System.currentTimeMillis() - startTime;

o.a.c.l.t.StopWatch

Обратите внимание, что Commons Lang имеет StopWatch, который можно использовать для измерения времени выполнения в миллисекундах. У него есть такие методы, как _ 4_, _ 5_, _ 6_ и т. д., которые позволяют проводить измерения в различных точках выполнения и могут оказаться удобными. Посмотри на это.

System.nanoTime ()

Вы можете предпочесть использовать System.nanoTime() < / a>, если вы ищете чрезвычайно точные измерения прошедшего времени. Из его javadoc:

long startTime = System.nanoTime();    
// ... the code being measured ...    
long estimatedTime = System.nanoTime() - startTime;

Другой вариант - использовать JAMon, инструмент, который собирает статистику (время выполнения, количество попаданий, среднее время выполнения, мин., макс. и т. д.) для любого кода, который находится между методами start () и stop (). Ниже очень простой пример:

import com.jamonapi.*;
...
Monitor mon=MonitorFactory.start("myFirstMonitor");
...Code Being Timed...
mon.stop();

Ознакомьтесь с этой статьей на www.javaperformancetunning.com, чтобы получить хорошее представление.

Использование АОП

Наконец, если вы не хотите загромождать свой код этими измерениями (или если вы не можете изменить существующий код), то АОП будет идеальным оружием. Я не собираюсь обсуждать это очень глубоко, но я хотел хотя бы упомянуть об этом.

Ниже очень простой аспект с использованием AspectJ и JAMon (здесь краткое имя pointcut будет использоваться для монитора 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;
    }
}

Определение pointcut можно легко адаптировать для мониторинга любого метода на основе имени класса, имени пакета, имени метода или любой их комбинации. Измерение - действительно идеальный вариант использования АОП.

Ваш новый класс:

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);

Впоследствии прошедшее время можно преобразовать в любой формат, который вам нравится, например, с помощью календаря.

Greetz, GHad

Если цель состоит в том, чтобы просто напечатать приблизительную информацию о времени в журналах вашей программы, то простое решение для проектов Java - не писать собственные классы секундомера или таймера, а просто использовать org.apache.commons.lang.time.StopWatch класс, который является частью Apache Commons Lang.

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);

tl;dr

например, если startTime равен 23:00, а endTime 1:00, чтобы получить продолжительность 2:00.

Невозможно. Если у вас только время суток, часы останавливаются в полночь. Без контекста дат, как мы узнаем, имеете ли вы в виду 1 час ночи следующего дня, на следующей неделе или в следующем десятилетии?

Таким образом, переход с 23:00 до 1:00 означает движение назад во времени на 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 измерить прошедшее время?

1. Захватите текущий момент в формате UTC с помощью Instant.now() .
2. Запечатлейте еще один такой момент позже.
3. Передайте оба значения в _ 3_.
4. (a) Из полученного объекта Duration извлеките количество 24-часовых дней, часов, минут, секунд и долей секунды в наносекундах, вызвав различные методы to…Part.
   (b) Или вызовите toString, чтобы сгенерировать String в стандартном формате ISO 8601 из PnYnMnDTnHnMnS.

Пример кода с использованием пары объектов 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 8 и более поздних версий, java.time framework.

java.time

Фреймворк java.time определяется JSR 310, вдохновленным очень успешным < проект href = "http://www.joda.org/joda-time/" rel = "noreferrer"> Joda-Time, расширенный ThreeTen-Extra, описанный в Oracle Tutorial.

Старые классы даты и времени, такие как java.util.Date/.Calendar, связанные с самыми ранними версиями Java, оказались плохо спроектированными, запутанными и неудобными. Их вытесняют классы java.time.

разрешение

В других ответах обсуждается разрешение.

Классы java.time имеют наносекунду разрешение до девяти цифр десятичной доли секунды. Например, 2016-03-12T04:29:39.123456789Z.

И старые классы java.util.Date/.Calendar, и классы Joda-Time имеют разрешение в миллисекундах (3 цифры дроби). Например, 2016-03-12T04:29:39.123Z.

В Java 8 текущий момент выбирается с разрешением до миллисекунды из-за устаревшей проблемы. В Java 9 и более поздних версиях текущее время может быть определено с точностью до наносекунды, если аппаратные часы вашего компьютера работают так точно.

Время суток

Если вы действительно хотите работать только с временем суток, без даты или часового пояса, используйте _ 13_ класс.

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

ISO 8601

Обратите внимание, что по умолчанию Duration::toString выводится в стандартном формате ISO 8601. В этом формате P обозначает начало (как в «Периоде»), а T отделяет любую часть «годы-месяцы-дни» от части «часы-минуты-секунды».

Пересечение полуночи

К сожалению, работать со временем суток становится сложно, только когда вы переводите круглосуточно, пересекая полночь. Класс LocalTime обрабатывает это, предполагая, что вы хотите вернуться к более раннему моменту дня.

Использование того же кода, что и выше, но переход от 23:00 к 01:00 дает отрицательные двадцать два часа (PT-22H).

LocalTime sooner = LocalTime.of ( 23, 0 );
LocalTime later = LocalTime.of ( 1, 0 );

раньше: 23:00 | позже: 01:00 | продолжительность: ПТ-22Н

Дата-время

Если вы намереваетесь пересечь полночь, вам, вероятно, имеет смысл работать со значениями даты и времени, а не только со значениями времени суток.

Часовой пояс

Часовой пояс имеет решающее значение для дат. Итак, мы указываем три элемента: (1) желаемую дату, (2) желаемое время дня и (3) часовой пояс как контекст, с помощью которого можно интерпретировать эту дату и время. Здесь мы произвольно выбираем часовой пояс Монреаль.

Если вы определяете дату только с помощью смещения от UTC, используйте _ 26_ с _ 27_. Если у вас есть полный часовой пояс (смещение плюс правила обработки аномалий, таких как переход на летнее время), используйте _ 28_ с _ 29_.

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.time framework встроена в Java 8 и новее. Эти классы заменяют неудобные старые устаревшие классы даты и времени, такие как _ 35_, _ 36_, & _ 37_.

Проект Joda-Time теперь в режим обслуживания, советует перейти на java.time классы.

Чтобы узнать больше, см. Учебник Oracle . И поищите в Stack Overflow множество примеров и объяснений. Спецификация - JSR 310.

Вы можете обмениваться объектами java.time непосредственно с вашей базой данных. Используйте драйвер JDBC, совместимый с JDBC 4.2 или новее. Нет необходимости в строках, нет необходимости в java.sql.* классах.

Где взять классы java.time?

• Java SE 8, Java SE 9, Java SE 10, and later
  • Built-in.
  • Часть стандартного Java API со встроенной реализацией.
  • В Java 9 добавлены некоторые незначительные функции и исправления.
• Java SE 6 and Java SE 7
  • Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
• Android
  • Later versions of Android bundle implementations of the java.time classes.
  • Для более ранней версии Android (‹26) тег ThreeTenABP проект адаптирует ThreeTen-Backport (упомянутый выше). См. Как использовать ThreeTenABP….

Проект ThreeTen-Extra расширяет java.time дополнительными классами. Этот проект является испытательной площадкой для возможных будущих дополнений к java.time. Здесь вы можете найти несколько полезных классов, например _39 _, YearWeek, _ 41_ и подробнее.

Стоит отметить, что

• System.currentTimeMillis () в лучшем случае имеет точность до миллисекунды. В некоторых системах Windows оно может составлять 16 мс. Он имеет меньшую стоимость, чем альтернативы ‹200 нс.
• System.nanoTime () имеет точность всего до микросекунды в большинстве систем и может прыгать в системах Windows на 100 микросекунд (т.е. иногда это не так точно, как кажется)
• Календарь - очень дорогой способ расчета времени. (я могу думать об этом отдельно от XMLGregorianCalendar) Иногда это наиболее подходящее решение, но имейте в виду, что вам следует использовать только длинные интервалы времени.

Какие типы использовать для этого в 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 предоставляет статический метод System.currentTimeMillis(). И это возвращает длинное значение, так что это хорошая ссылка. Многие другие классы принимают параметр timeInMillis, который также является длинным.

И многим людям проще использовать библиотеку Joda Time для вычисления даты и времени. .

Если вы предпочитаете использовать Calendar API Java, можете попробовать это,

Date startingTime = Calendar.getInstance().getTime();
//later on
Date now = Calendar.getInstance().getTime();
long timeElapsed = now.getTime() - startingTime.getTime();

Если вы пишете приложение, которое должно работать с продолжительностью времени, обратите внимание на Joda-Time, в котором есть класс, специально предназначенный для обработки длительностей, Интервалы и периоды. Ваш метод getDuration() выглядит так, как будто он может возвращать интервал времени Joda:

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);
}

Если вы получаете метки времени от System.currentTimeMillis(), тогда ваши временные переменные должны быть длинными.

Я обнаружил, что этот код полезен при выборе времени:

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" может исправить это

Я построил функцию форматирования на основе материала, который я украл SO. Мне нужен был способ «профилирования» материалов в сообщениях журнала, поэтому мне нужно было сообщение фиксированной продолжительности.

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));

  }

}