Jakich typów użyć, aby to osiągnąć w Javie?

Krótka odpowiedź to long. Teraz więcej o tym, jak zmierzyć...

System.currentTimeMillis ()

"tradycyjnym" sposobem na to jest rzeczywiście użycie System.currentTimeMillis():

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

O. A.c.L.T.Stoper

Zauważ, że Commons Lang posiada klasęStopWatch , która może być używana do mierzenia czasu wykonania w milisekundach. Posiada metody takie jak split(), suspend(), resume(), itp, które pozwalają na podjęcie pomiaru w różnych punktach wykonania i które mogą okazać się wygodne. Spójrz na to.

System.nanoTime ()

Możesz użyć System.nanoTime() Jeśli szukasz niezwykle precyzyjnych pomiarów upływającego czasu. Z jego javadoc:

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

Jamon

Inną opcją byłoby użycie JAMon , narzędzia, które zbiera statystyki (Czas wykonania, liczba trafień, średni czas wykonania, min, max, itp.) dla dowolnego kodu, który znajduje się pomiędzy metodami start() i stop (). Poniżej bardzo prosty przykład:

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

Zobacz Ten artykuł na www.javaperformancetunning.com za miłe wprowadzenie.

Korzystanie z AOP

Wreszcie, jeśli nie chcesz zaśmiecać kodu tymi pomiarami (lub jeśli nie możesz zmienić istniejącego kodu), AOP będzie idealną bronią. Nie będę o tym zbyt głęboko dyskutował, ale chciałem przynajmniej wspomnij o tym.

Poniżej bardzo prosty aspekt przy użyciu AspectJ i JAMon (tutaj krótka nazwa pointcut będzie używana dla monitora JAMon, stąd wywołanie do 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;
    }
}

Definicja pointcut może być łatwo dostosowana do monitorowania dowolnej metody opartej na nazwie klasy, nazwie pakietu, nazwie metody lub dowolnej kombinacji tych metod. Pomiar jest naprawdę idealnym przypadkiem użycia dla AOP.

Twoja nowa klasa:

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

Użycie:

    TimeWatch watch = TimeWatch.start();
    // do something
    long passedTimeInMs = watch.time();
    long passedTimeInSeconds = watch.time(TimeUnit.SECONDS);

Następnie, czas może być przekonwertowany na dowolny format, na przykład za pomocą kalendarza

Jeśli celem jest po prostu drukowanie grubych informacji o czasie do dzienników programu, to łatwym rozwiązaniem dla projektów Java nie jest pisanie własnych klas stopera lub timera, ale po prostu użycie org.apache.commons.lang.time.StopWatch klasa, która jest częścią 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

Na przykład, jeśli czas rozpoczęcia jest 23:00, a czas zakończenia 1:00, aby uzyskać czas trwania 2:00.

Niemożliwe. Jeśli masz tylko czas dnia, zegar zatrzymuje się o północy. Bez kontekstu dat, skąd wiemy, czy masz na myśli 1 w nocy następnego dnia, przyszłego tygodnia lub następnej dekady?

Więc przejście od 23 do 1 w nocy oznacza przesunięcie do tyłu w czasie 22 godzin, uruchamiając ręce zegara w kierunku przeciwnym do ruchu wskazówek zegara. Zobacz wynik poniżej, a negatywny dwadzieścia dwie godziny.

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

Przekroczenie północy wymaga szerszego kontekstu daty oprócz pory dnia(patrz niżej).

Jak zmierzyć czas, który upłynął w Javie?

1. uchwycić bieżący moment w UTC, z Instant.now().
2. Uchwyć kolejny taki moment później.
3. przekazać oba do Duration.between.
4. (a) z wynikowego Duration obiektu, wyodrębnij liczbę 24-godzinne dni, godziny, minuty, sekundy i ułamkowa sekunda w nanosekundach przez wywołanie różnych metod to…Part.
   (b) lub wywołanie toString, aby wygenerować String w standardowym formacie ISO 8601 Z PnYnMnDTnHnMnS.

Przykładowy kod, wykorzystujący parę Instant obiektów.

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

Nowa Technologia W Javie 8 +

Mamy do tego nową technologię wbudowaną w Javę 8, a później java.czas ramy.

Java.czas

Java.ramy czasowe są definiowane przez JSR 310 , inspirowane bardzo udanym projektemJoda-Time , rozszerzonym oThreeTen-Extra i opisanym wOracle Tutorial .

Stare klasy date-time, takie jak java.util.Data/Kalendarz dołączony do najwcześniejszych wersji Javy okazał się źle zaprojektowany, mylący i kłopotliwy. Są wypierane przez Javę.czas klasy.

Uchwała

Inne odpowiedzi

Java.klasy czasu mają rozdzielczość nanosekundy , do dziewięciu cyfr ułamka dziesiętnego sekundy. Na przykład 2016-03-12T04:29:39.123456789Z.

Zarówno stara java.util.Data/Klasy kalendarza i klasy czasu Joda mają rozdzielczość milisekund (3 cyfry ułamka). Na przykład 2016-03-12T04:29:39.123Z.

W Javie 8 bieżący moment jest pobierany z rozdzielczością do milisekundy, ponieważ problem z dziedzictwem. W wersji Java 9 i nowszej bieżący czas można określić do rozdzielczości nanosekund, pod warunkiem, że zegar sprzętowy komputera działa tak precyzyjnie.

Czas Dnia

Jeśli naprawdę chcesz pracować tylko z czasem dnia bez daty lub strefy czasowej, użyj LocalTime klasy.

LocalTime sooner = LocalTime.of ( 17, 00 );
LocalTime later = LocalTime.of ( 19, 00 );

A Duration reprezentuje przedział czasu, który określa się jako liczbę sekund plus nanosekundy.

Duration duration = Duration.between ( sooner, later );

Zrzut do konsoli.

System.out.println ( "sooner: " + sooner + " | later: " + later + " | duration: " + duration );

[[44]}wcześniej: 17: 00 | później:19: 00 / Czas trwania: PT2H

ISO 8601

Zwróć uwagę, że domyślne wyjście {[22] } jest w standardowym formacie ISO 8601 . W tym formacie P oznacza początek (jak w 'Period'), a T oddziela dowolną część lat-miesięcy-dni od części Godzin-Minut-Sekund.

Crossing Midnight

Użycie tego samego kodu jak powyżej, ale przejście od 23:00 do 01:00 daje wynik ujemny 22 godziny (PT-22H).

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

[[44]}wcześniej: 23: 00 | później:01: 00 / Czas trwania: PT-22h

Data-Czas

Jeśli zamierzasz przekroczyć północ, prawdopodobnie ma to sens, abyś pracował z wartościami daty i czasu, a nie tylko czasu dnia.

Czas Strefa

Jeśli zdefiniujesz datę tylko przez offset-from-UTC, użyj ZoneOffset Z OffsetDateTime. Jeśli masz pełną strefę czasową (offset plus zasady postępowania z anomaliami, takimi jak światło dzienne Oszczędność czasu), użyj ZoneId Z ZonedDateTime.

LocalDate localDate = LocalDate.of ( 2016, 1, 23 );
ZoneId zoneId = ZoneId.of ( "America/Montreal" );
ZonedDateTime sooner = ZonedDateTime.of ( localDate, LocalTime.of ( 23, 0 ), zoneId );

Określamy późniejszą godzinę jako następny dzień o 1: 00 rano.

ZonedDateTime later = ZonedDateTime.of ( localDate.plusDays ( 1 ), LocalTime.of ( 1, 0 ), zoneId );

Obliczamy Duration w taki sam sposób jak powyżej. Teraz mamy dwie godziny oczekiwane przez to pytanie.

Duration duration = Duration.between ( sooner, later );

Zrzut do konsoli.

System.out.println ( "sooner: " + sooner + " | later: " + later + " | duration: " + duration );

Wcześniej: 2016-01-23t23:00-05:00[Ameryka/Montreal] | później: 2016-01-24t01:00-05:00[Ameryka/Montreal] | czas trwania: PT2H

Daylight Saving Czas

Jeśli data-godziny były związane z czasem letnim (DST) lub inną taką anomalią, java.klasy czasu dostosowywałyby się w razie potrzeby. Przeczytaj klasę doc po szczegóły.

O Javie.czas

The java.czas framework jest wbudowany w Java 8 i nowsze. Klasy te zastępują kłopotliwe staredziedzictwo klasy date-time, takie jak java.util.Date, Calendar, & SimpleDateFormat.

The Joda-czas projekt, obecnie w trybie konserwacji , radzi migrację do java.czas klasy.

Aby dowiedzieć się więcej, Zobacz samouczek Oracle. I wyszukaj przepełnienie stosu dla wielu przykładów i wyjaśnień. Specyfikacja to JSR 310 .

Możesz wymienić Javę.obiekty time bezpośrednio z bazą danych. Użyj sterownika JDBCzgodnego z JDBC 4.2 lub nowszego. Nie ma potrzeby strings, no need for java.sql.* classes.

Skąd pobrać Javę.zajęcia czasowe?

• Java SE 8, Java SE 9, Java SE 10, i Później
  • Wbudowany.
  • część standardowego API Java z pakietową implementacją.
  • Java 9 dodaje kilka drobnych funkcji i poprawek.
• Java SE 6 oraz Java SE 7
  • Większość Javy.funkcja czasu powraca-przeportowana do Javy 6 i 7 w ThreeTen-Backport.
• Android
  • późniejsze wersje Android bundle implementacji java.zajęcia czasowe.
  • dla wcześniejszego Androida ( ThreeTenABP

The ThreeTen-Extra projekt rozszerza Javę.czas z dodatkowymi zajęciami. Ten projekt jest poligonem dla potencjalnych przyszłych dodatków do Javy.czas. Możesz znaleźć tutaj kilka przydatnych klas, takich jak Interval, YearWeek, YearQuarter, i więcej.

Java dostarcza statyczną metodę System.currentTimeMillis(). A to zwraca długą wartość, więc jest to dobry punkt odniesienia. Wiele innych klas akceptuje parametr 'timeInMillis', który jest również długi.

I wielu osobom łatwiej jest korzystać z biblioteki Joda Time do wykonywania obliczeń dat i godzin.

jakich typów użyć, aby to osiągnąć w Javie?

Odpowiedź: long

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

Użycie:

  Stream s = .... 

  s.start();

  // do something for a while 

  s.stop();

  s.getDuration(); // gives the elapsed time in milliseconds. 

Na ostatnią "notkę" sugerowałbym użycie czasu Joda. Zawiera klasę odpowiednią do tego, czego potrzebujesz.

Warto zauważyć, że

• System.currentTimeMillis() ma co najwyżej milisekundową dokładność. Warto Jego może być 16 ms na niektórych systemach windows. Ma niższy koszt niż alternatywy
• System.nanoTime() jest dokładna tylko do mikrosekund na większości systemów i może przeskoczyć na systemach windows o 100 mikrosekund (tzn. czasami nie jest tak dokładna, jak się wydaje)
Kalendarz jest bardzo kosztownym sposobem obliczania czasu. (mogę myśleć oprócz XMLGregorianCalendar) czasami jest to najbardziej odpowiednie rozwiązanie, ale należy pamiętać, że należy tylko w długich odstępach czasu.

Jeśli piszesz aplikację, która musi zajmować się czasem trwania, to proszę spojrzeć na Joda-Time, która ma klasę specjalnie do obsługi czasu trwania, interwały i okresy. Twoja metoda getDuration() wygląda na to, że może zwrócić przedział czasu 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);
}

Jeśli wolisz używać Java Calendar API Możesz spróbować tego,

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

Jeśli otrzymujesz znaczniki czasu z System.currentTimeMillis(), to twoje zmienne czasowe powinny być długie.

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

Uznałem ten kod za przydatny przy timingach:

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

Użyj tego:

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

(ważne jest również, aby na przykład, jeśli czas rozpoczęcia jest 23:00, a czas zakończenia 1:00, aby uzyskać czas trwania 2:00.)

The "else" part can get it correct

Zbudowałem funkcję formatowania na podstawie rzeczy, które ukradłem. Potrzebowałem sposobu "profilowania" rzeczy w wiadomościach dziennika, więc potrzebowałem wiadomości o stałej długości czasu trwania.

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

I klasa testowa:

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

  }

}