Ich habe frühere Fragen durchgesehen, aber keiner hatte die Antwort, die ich suchte. Wie konvertiere ich Millisekunden von einer StopWatch-Methode in Minuten und Sekunden? Ich habe:

 watch.start();

um die Stoppuhr zu starten und

  watch.stop();

die Uhr anhalten. Ich habe später

  watch.getTime();

was Millisekunden zurückgibt. Ich möchte, dass es in Sekunden und Minuten zurückkehrt. Wie mache ich das? Ich suche nach einer Möglichkeit, dies zu tun, ohne mit 1000 zu multiplizieren / zu dividieren, sondern nach einer Methode, die die gesamte Berechnung lesbarer und weniger fehleranfällig macht.

Ich würde vorschlagen, zu verwenden TimeUnit. Sie können es so verwenden:

long minutes = TimeUnit.MILLISECONDS.toMinutes(millis);
long seconds = TimeUnit.MILLISECONDS.toSeconds(millis);

Nach der Umrechnung von Millis in Sekunden (durch Teilen durch 1000) können Sie den Minutenwert / 60und % 60(den Rest) den Wert "Sekunden in Minuten" ermitteln.

long millis = .....;  // obtained from StopWatch
long minutes = (millis / 1000)  / 60;
int seconds = (int)((millis / 1000) % 60);

tl; dr

Duration d = Duration.ofMillis( … ) ;
int minutes = d.toMinutesPart() ;
int seconds = d.toSecondsPart() ;

Java 9 und höher

Erstellen Sie in Java 9 und höher a Durationund rufen Sie die to…PartMethoden auf. In diesem Fall: toMinutesPartund toSecondsPart.

Erfassen Sie den Start und Stopp Ihrer Stoppuhr.

Instant start = Instant.now(); 
…
Instant stop = Instant.now();

Stellen Sie die verstrichene Zeit in einem DurationObjekt dar.

Duration d = Duration.between( start , stop );

Fragen Sie für jeden Teil die Minuten und die Sekunden ab.

int minutes = d.toMinutesPart();
int seconds = d.toSecondsPart();

Vielleicht möchten Sie auch sehen, ob Ihre Stoppuhr erwartungsgemäß lange lief.

Boolean ranTooLong = ( d.toDaysPart() > 0 ) || ( d.toHoursPart() > 0 ) ;

Java 8

In Java 8 Durationfehlen der Klasse to…PartMethoden. Sie müssen wie in den anderen Antworten gezeigt rechnen.

long entireDurationAsSeconds = d.getSeconds();

Oder lassen DurationSie die Mathematik machen.

long minutesPart = d.toMinutes(); 
long secondsPart = d.minusMinutes( minutesPart ).getSeconds() ;

Siehe Live-Code in IdeOne.com .

Intervall: 2016-12-18T08: 39: 34.099Z / 2016-12-18T08: 41: 49.099Z

d.toString (): PT2M15S

d.getSeconds (): 135

Verstrichen: 2M 15S

Auflösung

Zu Ihrer Information, die Auflösung von nowMethoden wurde zwischen Java 8 und Java 9 geändert. Siehe diese Frage .

• Java 9 erfasst den Moment mit einer Auflösung von nur Nanosekunden. Die Auflösung hängt von der Leistungsfähigkeit der Hardware Ihres Computers ab. Ich sehe Mikrosekunden (sechs Nachkommastellen) auf dem MacBook Pro Retina mit macOS Sierra.
• Java 8 erfasst den Moment nur bis zu Millisekunden. Die Implementierung von Clockist auf eine Auflösung von Millisekunden beschränkt. Sie können Werte also in Nanosekunden speichern , aber nur in Millisekunden erfassen .

Über java.time

Das java.time- Framework ist in Java 8 und höher integriert. Diese Klassen verdrängen die lästigen alten Legacy - Datum-Zeit - Klassen wie java.util.Date, Calendar, & SimpleDateFormat.

Weitere Informationen finden Sie im Oracle-Lernprogramm . Suchen Sie im Stapelüberlauf nach vielen Beispielen und Erklärungen. Die Spezifikation ist JSR 310 .

Das Joda-Time- Projekt, das sich jetzt im Wartungsmodus befindet , empfiehlt die Migration zu den Klassen java.time .

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

Woher bekomme ich die java.time-Klassen?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 und höher - Teil der Standard-Java-API mit einer gebündelten Implementierung.
  • Java 9 fügt einige kleinere Funktionen und Korrekturen hinzu.
• Java SE 6 und Java SE 7
  • Die meisten Funktionen von java.time werden in ThreeTen-Backport auf Java 6 & 7 zurückportiert .
• Android
  • Spätere Versionen von Android-Bundle-Implementierungen der Klassen java.time .
  • Für frühere Android -Geräte ( <26) passt das ThreeTenABP- Projekt ThreeTen-Backport (oben erwähnt) an. Siehe Verwendung von ThreeTenABP… .

Dies ist nur grundlegende Mathematik. 1000 Millisekunden = 1 Sekunde und 60000 Millisekunden = 1 Minute; Also mach es einfach,

int seconds=(millis/1000)%60;

long minutes=((millis-seconds)/1000)/60;

Ich habe eine MP3-Player-App für Android erstellt, also habe ich es so gemacht, um die aktuelle Zeit und Dauer zu erhalten

 private String millisecondsToTime(long milliseconds) {
    long minutes = (milliseconds / 1000) / 60;
    long seconds = (milliseconds / 1000) % 60;
    String secondsStr = Long.toString(seconds);
    String secs;
    if (secondsStr.length() >= 2) {
        secs = secondsStr.substring(0, 2);
    } else {
        secs = "0" + secondsStr;
    }

    return minutes + ":" + secs;
}

Hier ist das vollständige Programm

import java.util.concurrent.TimeUnit;

public class Milliseconds {

public static void main(String[] args) {
    long milliseconds = 1000000;

    // long minutes = (milliseconds / 1000) / 60;
    long minutes = TimeUnit.MILLISECONDS.toMinutes(milliseconds);

    // long seconds = (milliseconds / 1000);
    long seconds = TimeUnit.MILLISECONDS.toSeconds(milliseconds);

    System.out.format("%d Milliseconds = %d minutes\n", milliseconds, minutes );
    System.out.println("Or");
    System.out.format("%d Milliseconds = %d seconds", milliseconds, seconds );

}
}

Ich habe dieses Programm hier " Link " gefunden, dort wird es ausführlich erklärt.

X Millisekunden = X / 1000 Sekunden = (X / 1000) / 60 Minuten

Wenn Sie 100.000 Millisekunden haben, teilen Sie diesen Wert durch 1.000 und Sie haben 100 Sekunden Zeit. Jetzt 100/60 = 1,666 ~ Minuten, aber Bruchminuten haben keinen Wert, also: 100% 60 = 40 Sekunden, um den Rest zu finden, dann ganzzahlige Division 100/60 = 1 Minute, mit 40 Sekunden Rest. Antwort: 1 Minute, 40 Sekunden.

So konvertieren Sie die Zeit in Millis direkt in Minuten: Das zweite Format können Sie verwenden

String durationText = DateUtils.formatElapsedTime(timeInMillis / 1000));

Dies gibt eine Zeichenfolge mit der Zeit in der richtigen Formatierung zurück. Es hat bei mir funktioniert.

Versuchen Sie diesen Code, um die tatsächlichen Stunden, Minuten und Sekunden zu erhalten, die auf der Uhr angezeigt werden

val sec = (milliSec/1000) % 60
val min = ((milliSec/1000) / 60) % 60
val hour = ((milliSec/1000) / 60) / 60

Sie können versuchen, folgendermaßen vorzugehen:

Übergeben Sie den ms-Wert von

Long ms = watch.getTime();

zu

getDisplayValue(ms)

Kotlin-Implementierung:

fun getDisplayValue(ms: Long): String {
        val duration = Duration.ofMillis(ms)
        val minutes = duration.toMinutes()
        val seconds = duration.minusMinutes(minutes).seconds

        return "${minutes}min ${seconds}sec"
}

Java-Implementierung:

public String getDisplayValue(Long ms) {
        Duration duration = Duration.ofMillis(ms);
        Long minutes = duration.toMinutes();
        Long seconds = duration.minusMinutes(minutes).getSeconds();

        return minutes + "min " + seconds "sec"
}

  public static String getIntervalTime(long longInterval) {

    long intMillis = longInterval;
    long dd = TimeUnit.MILLISECONDS.toDays(intMillis);
    long daysMillis = TimeUnit.DAYS.toMillis(dd);
    intMillis -= daysMillis;
    long hh = TimeUnit.MILLISECONDS.toHours(intMillis);
    long hoursMillis = TimeUnit.HOURS.toMillis(hh);
    intMillis -= hoursMillis;
    long mm = TimeUnit.MILLISECONDS.toMinutes(intMillis);
    long minutesMillis = TimeUnit.MINUTES.toMillis(mm);
    intMillis -= minutesMillis;
    long ss = TimeUnit.MILLISECONDS.toSeconds(intMillis);
    long secondsMillis = TimeUnit.SECONDS.toMillis(ss);
    intMillis -= secondsMillis;

    String stringInterval = "%02d days - %02d:%02d:%02d.%03d";
    return String.format(stringInterval , dd, hh, mm, ss, intMillis);
  }

Testen

long delay = 1000*60*20 + 1000*5 + 10;
LOGGER.log(Level.INFO, "Delay Expected {0}", getIntervalTime(delay));

Ausgabe

INFO: Delay Expected 00 days - 00:20:05.010

Ich glaube nicht, dass Java 1.5 die gleichzeitige TimeUnit unterstützt. Ansonsten würde ich für TimeUnit vorschlagen. Das Folgende basiert auf einem reinen mathematischen Ansatz.

stopWatch.stop();
long milliseconds = stopWatch.getTime();

int seconds = (int) ((milliseconds / 1000) % 60);
int minutes = (int) ((milliseconds / 1000) / 60);

Sie können Millisekunden einfach in Sekunden, Minuten und Stunden umrechnen.

                val millis = **milliSecondsYouWantToConvert**
                val seconds = (millis / 1000) % 60
                val minutes = ((millis / 1000) / 60) % 60
                val hours = ((millis / 1000) / 60) / 60

                println("--------------------------------------------------------------------")
                println(String.format("%02dh : %02dm : %02ds remaining", hours, minutes, seconds))
                println("--------------------------------------------------------------------")
**RESULT :** 
--------------------------------------------------------------------
  01h : 23m : 37s remaining
--------------------------------------------------------------------

Der folgende Code erledigt die Konvertierung von ms in min: secs im Format [m: ss]

int seconds;
int minutes;
String Sec;
long Mills = ...;  // Milliseconds goes here
minutes = (int)(Mills / 1000)  / 60;
seconds = (int)((Mills / 1000) % 60);
Sec = seconds+"";

TextView.setText(minutes+":"+Sec);//Display duration [3:40]

package com.v3mobi.userpersistdatetime;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.Toast;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class UserActivity extends AppCompatActivity {

    Date startDate;
    Date endDate;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_user);
        startDate = java.util.Calendar.getInstance().getTime(); //set your start time
    }

    @Override
    protected void onStop() {
        super.onStop();
        endDate = java.util.Calendar.getInstance().getTime(); // set  your end time

        chekUserPersistence();

    }

    private void chekUserPersistence()
    {
        long duration = endDate.getTime() - startDate.getTime();
//        long duration = 301000;

        long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(duration);         // minutes ok
        long secs = (duration/1000) % 60;         // minutes ok


        Toast.makeText(UserActivity.this, "Diff  "
                +  diffInMinutes + " : "+ secs , Toast.LENGTH_SHORT).show();

        System.out.println("Diff  " + diffInMinutes +" : "+ secs );

        Log.e("keshav","diffInMinutes -->" +diffInMinutes);
        Log.e("keshav","secs -->" +secs);
        finish();
    }
}

Hier ist eine einfache Lösung. Beispielaufrufe, die in jeder Methode verwendet werden können:

• StopWatch.start();
• StopWatch.stop();

• StopWatch.displayDiff();Zeigt den Unterschied in Minuten und Sekunden zwischen Start und Stopp an. (verstrichene Zeit)

  import java.time.Duration;
  import java.time.Instant;
  
  
  public class StopWatch {
  
      private static Instant start;
      private static Instant stop;
  
      private void StopWatch() {
          // not called
      }
  
      public static void start() {
          start = Instant.now();
      }
  
      public static void stop() {
          stop = Instant.now();
      }
  
      public static void displayDiff() {
          Duration totalTime = Duration.between(start, stop);
          System.out.println(totalTime.toMinutes() + " Minutes " 
                             + totalTime.toMillis() / 1000 + " Seconds");
      }
  }