it-swarm.com.de

Wie messe ich die abgelaufene Zeit in Java?

Ich möchte so etwas haben:

public class Stream
{
    public startTime;
    public endTime;

    public getDuration()
    {
        return startTime - endTime;
    }
}

Es ist auch wichtig, dass zum Beispiel, wenn die Startzeit 23:00 und die Endzeit 1:00 ist, eine Dauer von 2:00 erreicht wird.

Welche Typen müssen verwendet werden, um dies in Java zu erreichen?

301
Omu

Leider ist keine der zehn bisher gestellten Antworten richtig.

Wenn Sie die abgelaufene Zeit messen und möchten, dass es correct ist, müssen Sie System.nanoTime() verwenden. Sie können System.currentTimeMillis() nicht verwenden, es sei denn, Sie haben nichts dagegen, dass Ihr Ergebnis falsch ist.

Der Zweck von nanoTime ist es, die Zeit von verstrichen zu messen, und der Zweck von currentTimeMillis ist die Zeit von wall-clock. Sie können die eine nicht für den anderen Zweck verwenden. Der Grund ist, dass keine Computeruhr perfekt ist. es driftet immer und muss gelegentlich korrigiert werden. Diese Korrektur kann entweder manuell erfolgen oder bei den meisten Maschinen gibt es einen Prozess, der ausgeführt wird und ständig kleine Korrekturen an der Systemuhr ("Wanduhr") ausgibt. Diese treten häufig auf. Eine weitere derartige Korrektur findet immer dann statt, wenn es eine Schaltsekunde gibt.

Da nanoTime die verstrichene Zeit messen soll, wird sie von diesen kleinen Korrekturen nicht beeinflusst. Es ist, was Sie verwenden möchten. Jegliche Timings, die gerade mit currentTimeMillis laufen, sind aus - möglicherweise sogar negativ.

Sie können sagen: "Das hört sich nicht so an, als würde es jemals wirklich so viel ausmachen", worauf ich sage, vielleicht nicht, aber insgesamt ist korrekter Code nicht einfach besser als falscher Code? Außerdem ist nanoTime ohnehin kürzer.

Bisher veröffentlichte Disclaimer über nanoTime, die in der Regel eine Genauigkeit im Mikrosekundenbereich haben, sind gültig. Es kann auch mehr als eine Mikrosekunde dauern, um abhängig von den Umständen aufgerufen zu werden (wie auch die anderen), erwarten Sie also keine sehr kleinen Intervalle.

598

Welche Typen müssen verwendet werden, um dies in Java zu erreichen?

Die kurze Antwort lautet long. Nun mehr zum Messen ...

System.currentTimeMillis ()

Der "traditionelle" Weg, dies zu tun, ist in der Tat die Verwendung von System.currentTimeMillis() :

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

o.a.c.l.t.StopWatch

Beachten Sie, dass Commons Lang eine StopWatch -Klasse besitzt, mit der die Ausführungszeit in Millisekunden gemessen werden kann. Es verfügt über Methoden wie split() , suspend() , resume() etc, die es ermöglichen, an verschiedenen Punkten der Ausführung Maßnahmen zu ergreifen, und die Sie für geeignet halten. Schau es dir an.

System.nanoTime ()

Sie können auch System.nanoTime() verwenden, wenn Sie nach äußerst genauen Messungen der abgelaufenen Zeit suchen. Aus seinem Javadoc: 

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

Jamon

Eine andere Option wäre die Verwendung von JAMon , einem Werkzeug, das statistics (Ausführungszeit, Anzahl der Treffer, durchschnittliche Ausführungszeit, Min, Max usw.) für jeden Code zwischen start () und stop sammelt () Methoden. Unten ein sehr einfaches Beispiel:

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

Check out diesen Artikel auf www.javaperformancetunning.com für eine nette Einführung.

AOP verwenden

Wenn Sie Ihren Code mit diesen Messungen nicht durcheinander bringen möchten (oder wenn Sie den vorhandenen Code nicht ändern können), wäre AOP eine perfekte Waffe. Ich werde das nicht sehr tief besprechen, aber ich wollte es wenigstens erwähnen. 

Nachfolgend ein sehr einfacher Aspekt, der AspectJ und JAMon verwendet (hier wird der Kurzname des Pointcut für den JAMon-Monitor verwendet, daher der Aufruf von 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;
    }
}

Die Pointcut-Definition kann leicht angepasst werden, um jede Methode basierend auf dem Klassennamen, dem Paketnamen, dem Methodennamen oder einer Kombination davon zu überwachen. Messung ist wirklich ein perfekter Anwendungsfall für AOP.

199
Pascal Thivent

Ihre neue Klasse:

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

Verwendungszweck:

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

Anschließend kann die verstrichene Zeit in ein beliebiges Format umgewandelt werden, beispielsweise mit einem Kalender

Greetz, GHad

36
GHad

Wenn Sie einfach grobe Timing-Informationen in Ihre Programmprotokolle drucken möchten, ist die einfache Lösung für Java-Projekte nicht das Erstellen eigener Stoppuhr- oder Timerklassen, sondern die Verwendung der Klasse org.Apache.commons.lang.time.StopWatch von 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);
19
David Bliss

tl; dr

beispiel: Wenn die Startzeit 23:00 Uhr und die Endzeit 1:00 Uhr ist, wird eine Dauer von 2:00 Uhr abgerufen.

Nicht möglich. Wenn Sie nur die Tageszeit haben, stoppt die Uhr um Mitternacht. Woher wissen wir ohne Datumskontext, ob Sie am nächsten Tag, in der nächsten Woche oder im nächsten Jahrzehnt 1 Uhr morgens meinen?

Also von 11 PM bis 1 Uhr morgens rückwärts in der Zeit 22 Stunden bewegen, die Zeiger der Uhr gegen den Uhrzeigersinn laufen lassen. Siehe das Ergebnis unten, a negativ zweiundzwanzig Stunden.

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

Um Mitternacht zu überqueren, ist neben der Uhrzeit auch der größere Datumskontext erforderlich (siehe unten).

Wie messe ich die in Java verstrichene Zeit?

  1. Erfassen Sie den aktuellen Moment in UTC mit Instant.now() .
  2. Halten Sie einen solchen Moment später fest.
  3. Übergeben Sie beide an Duration.between .
  4. (a) Extrahieren Sie aus dem resultierenden Objekt Duration eine Anzahl von 24-Stunden-Tagen, Stunden, Minuten, Sekunden und Sekundenbruchteilen in Nanosekunden, indem Sie die verschiedenen to…Part - Methoden aufrufen.
    (b) Oder rufen Sie toString auf, um String in ISO 8601-Standardformat von PnYnMnDTnHnMnS zu generieren.

Beispielcode mit zwei Instant -Objekten.

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

Neue Technologie In Java 8+

Wir haben eine neue Technologie dafür, die jetzt in Java 8 und höher, das Java.time Framework eingebaut ist.

Java.time

Das Java.time-Framework ist definiert durch JSR 31 , inspiriert durch das äußerst erfolgreiche Joda-Time -Projekt, erweitert durch das ThreeTen-Extra -Projekt, und beschrieben im Oracle Tutorial .

Die alten Date-Time-Klassen wie Java.util.Date/.Calendar, die mit den frühesten Versionen von Java) gebündelt sind, haben sich als schlecht gestaltet, verwirrend und problematisch erwiesen. Sie werden durch Java ersetzt .Zeitunterricht.

Auflösung

Andere Antworten diskutieren die Auflösung.

Die Java.time-Klassen haben eine Auflösung von Nanosekunden bis zu neun Stellen im Dezimalbruchteil einer Sekunde. Zum Beispiel 2016-03-12T04:29:39.123456789Z.

Sowohl die alten Java.util.Date/.Calendar-Klassen als auch die Joda-Time-Klassen haben eine Millisekundenauflösung (3-stelliger Bruch). Zum Beispiel 2016-03-12T04:29:39.123Z.

In Java 8 wird der aktuelle Zeitpunkt aufgrund eines Legacy-Problems nur mit einer Auflösung von Millisekunden abgerufen. In Java 9 und höher kann die aktuelle Uhrzeit angegeben werden Die Auflösung kann bis zu einer Nanosekunde betragen, sofern die Hardware-Uhr Ihres Computers so fein läuft.

Uhrzeit

Wenn Sie wirklich nur mit der Uhrzeit arbeiten möchten, für die Datum und Zeitzone fehlen, verwenden Sie die Klasse LocalTime .

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

Ein Duration repräsentiert eine Zeitspanne in Sekunden plus Nanosekunden.

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

Dump zur Konsole.

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

früher: 17:00 | später: 19:00 | Dauer: PT2H

ISO 8601

Beachten Sie, dass die Standardausgabe von Duration::toString Im Standardformat ISO 8601 vorliegt. In diesem Format markiert das P den Anfang (wie in 'Periode'), und das T trennt alle Jahre-Monate-Tage-Teile vom Stunden-Minuten-Sekunden-Teil.

Mitternacht überqueren

Leider wird das Arbeiten mit der Uhrzeit nur dann schwierig, wenn Sie rund um die Uhr über Mitternacht arbeiten. Die Klasse LocalTime behandelt dies, indem sie davon ausgeht, dass Sie zu einem früheren Zeitpunkt des Tages zurückkehren möchten.

Wenn Sie denselben Code wie oben verwenden, aber von 23:00 Nach 01:00 Wechseln, werden zweiundzwanzig Stunden negativ (PT-22H).

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

früher: 23:00 | später: 01:00 | Dauer: PT-22H

Terminzeit

Wenn Sie beabsichtigen, Mitternacht zu überschreiten, ist es wahrscheinlich sinnvoll, mit Datums- und Uhrzeitwerten zu arbeiten, anstatt nur mit Tageszeitwerten.

Zeitzone

Die Zeitzone ist für Datumsangaben von entscheidender Bedeutung. Daher geben wir drei Elemente an: (1) das gewünschte Datum, (2) die gewünschte Uhrzeit und (3) die Zeitzone als Kontext für die Interpretation dieses Datums und dieser Uhrzeit. Hier wählen wir willkürlich die Zeitzone des Montréal Gebiets.

Wenn Sie das Datum nur durch ein Offset-von-UTC definieren, verwenden Sie ein ZoneOffset mit einem OffsetDateTime =. Wenn Sie eine Vollzeitzone haben (Versatz plus Regeln für die Behandlung von Anomalien wie Sommerzeit), verwenden Sie ein ZoneId mit einem ZonedDateTime =.

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

Wir geben die spätere Zeit als nächsten Tag um 1:00 Uhr an.

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

Wir berechnen den Duration auf die gleiche Weise wie oben. Jetzt bekommen wir die zwei Stunden, die von dieser Frage erwartet werden.

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

Dump zur Konsole.

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

früher: 2016-01-23T23: 00-05: 00 [Amerika/Montreal] | später: 2016-01-24T01: 00-05: 00 [Amerika/Montreal] | Dauer: PT2H

Sommerzeit

Wenn die zur Verfügung stehenden Datums- und Uhrzeitangaben Sommerzeit (DST) oder eine andere Anomalie enthalten hätten, würden die Java.time-Klassen nach Bedarf angepasst. Lesen Sie das Klassendokument für Details.


About Java.time

Das Java.time Framework ist in Java 8 und höher. Diese Klassen ersetzen das lästige alte Legacy Datum-Zeit-Klassen wie Java.util.Date , Calendar , & SimpleDateFormat .

Das Joda-Time -Projekt, das sich jetzt im Wartungsmodus befindet, rät zur Migration in die Java.time -Klassen.

Weitere Informationen finden Sie im Oracle Tutorial . Durchsuchen Sie Stack Overflow nach vielen Beispielen und Erklärungen. Spezifikation ist JSR 31 .

Sie können Java.time Objekte direkt mit Ihrer Datenbank austauschen. Verwenden Sie einen JDBC-Treiber , der JDBC 4.2 oder höher entspricht. Keine Notwendigkeit für Zeichenketten, keine Notwendigkeit für Klassen Java.sql.*.

Woher bekommen Sie die Java.time-Klassen?

Das Projekt ThreeTen-Extra erweitert Java.time um zusätzliche Klassen. Dieses Projekt ist ein Testfeld für mögliche zukünftige Ergänzungen von Java.time. Hier finden Sie möglicherweise einige nützliche Klassen wie Interval , YearWeek , YearQuarter und mehr .

15
Basil Bourque

Java bietet die statische Methode System.currentTimeMillis(). Und das ist ein langer Wert, also eine gute Referenz. Viele andere Klassen akzeptieren einen 'timeInMillis'-Parameter, der ebenfalls lang ist.

Und viele Leute finden es einfacher, die Bibliothek Joda Time zu verwenden, um Datums- und Zeitangaben zu berechnen.

7
Andreas_D

Welche Typen müssen verwendet werden, um dies in Java zu erreichen?

Antwort: lang

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

Verwendungszweck:

  Stream s = .... 

  s.start();

  // do something for a while 

  s.stop();

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

Das ist meine direkte Antwort auf Ihre erste Frage. 

Für den letzten "Hinweis" würde ich vorschlagen, Joda Time zu verwenden. Es enthält eine Intervall Klasse, die für das, was Sie brauchen, geeignet ist.

6
OscarRyz

Das ist es wert, darauf hingewiesen zu werden

  • System.currentTimeMillis () hat bestenfalls eine Genauigkeit von nur Millisekunden. Bei einigen Windows-Systemen kann es bei Wert 16 ms sein. Es hat geringere Kosten als Alternativen <200 ns.
  • System.nanoTime () ist auf den meisten Systemen nur Mikrosekundengenau und kann auf Windows-Systemen um 100 Mikrosekunden springen (d. H. Manchmal ist es nicht so genau, wie es scheint)
  • Kalender ist eine sehr teure Methode, um die Zeit zu berechnen. (Ich kann außer an XMLGregorianCalendar denken) Manchmal ist es die am besten geeignete Lösung, aber seien Sie sich bewusst, dass Sie nur zeitlich lange Abstände machen sollten.
6
Peter Lawrey

Wenn Sie die Calendar API von Java bevorzugen, können Sie dies versuchen.

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

Wenn Sie eine Anwendung schreiben, die sich mit der Zeitdauer befassen muss, werfen Sie einen Blick auf Joda-Time, das eine Klasse speziell für die Behandlung von Dauern, Intervallen und Perioden enthält. Ihre getDuration()-Methode sieht so aus, als könnte sie ein Joda-Zeitintervall zurückgeben:

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);
}
3
David Bliss

Wenn Sie Ihre Zeitstempel von System.currentTimeMillis() erhalten, sollten Ihre Zeitvariablen lang sein.

1
uckelman
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
1
Shiva Sagan

Benutze das:

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

(Außerdem ist es wichtig, dass zum Beispiel die Startzeit 23:00 Uhr und die Uhrzeit 1:00 Uhr ist, um eine Dauer von 2:00 Uhr zu erhalten.)

der "else" Teil kann es richtig machen

0
N. N

Ich habe eine Formatierungsfunktion erstellt, die auf Elementen basiert, die ich von SO gestohlen habe. Ich brauchte eine Möglichkeit, Zeug in Protokollnachrichten zu "profilieren", also brauchte ich eine Nachricht mit fester Länge.

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

Und eine Testklasse:

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

  }

}
0
Buffalo

ich fand diesen Code nützlich beim Timing von Dingen:

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;
}
0
Ray Tayek