Ik heb eerdere vragen doorgenomen, maar geen enkele had het antwoord dat ik zocht.
Hoe converteer ik milliseconden van een StopWatch-methode naar Minuten en Seconden?
Ik heb:

watch.start();

om de stopwatch te starten en

 watch.stop();

om het horloge te stoppen. Ik heb later

 watch.getTime();

die milliseconden retourneert. Ik wil dat het terugkomt in seconden en minuten. Hoe ga ik dat doen? Ik ben op zoek naar een manier om dit te doen zonder te vermenigvuldigen/delen door 1000, maar eerder naar een methode die de hele berekening leesbaarder en minder foutgevoelig maakt.

Antwoord 1, autoriteit 100%

Ik raad aan om TimeUnitte gebruiken. Je kunt het als volgt gebruiken:

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

Antwoord 2, autoriteit 26%

Na het converteren van millis naar seconden (door te delen door 1000), kun je / 60gebruiken om de minutenwaarde te krijgen, en % 60(rest) om de ” seconden in minuut” waarde.

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

Antwoord 3, autoriteit 13%

tl;dr

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

Java 9 en hoger

Maak in Java 9 en hoger een Durationaan en roep de methoden to…Partaan. In dit geval: toMinutesParten toSecondsPart.

Leg de start & stop van uw stopwatch.

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

Geef de verstreken tijd weer in een Duration-object.

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

Ondervraag voor elk onderdeel de minuten en de seconden.

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

Misschien wil je ook zien of je stopwatch naar verwachting lang liep.

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

Java 8

In Java 8 mist de klasse Durationto…Part-methoden. U moet rekenen zoals weergegeven in de andere antwoorden.

long entireDurationAsSeconds = d.getSeconds();

Of laat Durationde rekensom maken.

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

Zie live code in IdeOne.com.

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

d.toString(): PT2M15S

d.getSeconds(): 135

Verstreken: 2M 15S

Oplossing

Ter info, de resolutie van now-methoden is gewijzigd tussen Java 8 en Java 9. Zie deze vraag.

• Java 9legt het moment vast met een resolutie die zo fijn is als nanoseconden. Resolutie is afhankelijk van de mogelijkheden van de hardware van uw computer. Ik zie microseconden (zes cijfers van decimale breuk) op MacBook Pro Retina met macOS Sierra.
• Java 8legt het moment slechts in milliseconden vast. De implementatie van Clockis beperkt tot een resolutie van milliseconden. U kunt dus waarden opslaanin nanoseconden, maar alleen vastleggenin milliseconden.

Over java.time

De java.timeframework is ingebouwd in Java 8 en hoger. Deze klassen vervangen de lastige oude legacydatum-tijdklassen zoals java.util.Date, Calendar, & SimpleDateFormat.

Zie voor meer informatie de Oracle-zelfstudie. En zoek Stack Overflow voor veel voorbeelden en uitleg. Specificatie is JSR 310.

Het Joda-Time-project, nu in onderhoudsmodus, adviseert migratie naar de java.timeklassen.

U kunt java.timeobjecten rechtstreeks uitwisselen met uw database. Gebruik een JDBC-stuurprogrammadat voldoet aan JDBC 4.2of hoger. Geen strings nodig, geen java.sql.*klassen.

Waar zijn de java.time-klassen te verkrijgen?

• Java SE 8, Java SE 9, Java SE 10, Java SE 11en later – Onderdeel van de standaard Java API met een gebundelde implementatie.
  • Java 9 voegt enkele kleine functies en oplossingen toe.
• Java SE 6en Java SE 7
  • De meeste java.time-functionaliteit is teruggekoppeld naar Java 6 & 7 in ThreeTen-Backport.
• Android
  • Latere versies van Android-bundelimplementaties van de klassen java.time.
  • Voor eerdere Android (<26), de ThreeTenABP-project past ThreeTen-Backport(hierboven vermeld). Zie ThreeTenABP gebruiken….

Antwoord 4, autoriteit 6%

Ik was een mp3-speler-app voor Android aan het maken, dus ik deed het zo om de huidige tijd en duur te krijgen

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

Antwoord 5, Autoriteit 6%

Dit is gewoon een basiswiskunde.
1000 milliseconden = 1 seconde en 60000 milliseconden = 1 minuut;
Dus doe het gewoon,

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

Antwoord 6, Autoriteit 4%

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

Kortere vorm!

 public static String getIntervalTime(long longInterval) {
    long intMillis = longInterval;
    long dd = TimeUnit.MILLISECONDS.toDays(intMillis);
    intMillis -= TimeUnit.DAYS.toMillis(dd);
    long hh = TimeUnit.MILLISECONDS.toHours(intMillis);
    intMillis -= TimeUnit.HOURS.toMillis(hh);
    long mm = TimeUnit.MILLISECONDS.toMinutes(intMillis);
    intMillis -= TimeUnit.MINUTES.toMillis(mm);
    long ss = TimeUnit.MILLISECONDS.toSeconds(intMillis);
    intMillis -= TimeUnit.SECONDS.toMillis(ss);
    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));

Uitvoer

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

Antwoord 7, autoriteit 3%

Om tijd in milli’s direct om te zetten in minuten: tweede formaat kun je dit gebruiken

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

Dit retourneert een tekenreeks met de tijd in de juiste opmaak.
Het werkte voor mij.

Antwoord 8, autoriteit 3%

X milliseconden = X / 1000 seconden = (X / 1000) / 60 minuten

Als je 100.000 milliseconden hebt, deel je deze waarde door 1.000 en je houdt 100 seconden over. Nu 100 / 60 = 1.666~ minuten, maar fractionele minuten hebben geen waarde, dus: doe 100 % 60 = 40 seconden om de rest te vinden, dan integer delen 100 / 60 = 1 minuut, met 40 seconden rest. Antwoord: 1 minuut, 40 seconden.

Antwoord 9, autoriteit 3%

Hier is het volledige programma

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

Ik vond dit programma hier “Link” daar is het in detail uitgelegd.

Antwoord 10, autoriteit 2%

Probeer deze code om de werkelijke uren, minuten en seconden te krijgen zoals weergegeven op het horloge

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

Antwoord 11, autoriteit 2%

U kunt op deze manier proberen te werk te gaan:

Ms-waarde doorgeven van

Long ms = watch.getTime();

naar

getDisplayValue(ms)

Kotlin-implementatie:

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-implementatie:

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

Antwoord 12

Ik denk niet dat Java 1.5 gelijktijdige TimeUnit ondersteunt. Anders zou ik TimeUnit aanraden. Hieronder is gebaseerd op pure wiskundige benadering.

stopWatch.stop();
long milliseconds = stopWatch.getTime();
int seconds = (int) ((milliseconds / 1000) % 60);
int minutes = (int) ((milliseconds / 1000) / 60);

Antwoord 13

Je kunt milliseconden gemakkelijk omzetten in seconden, minuten en uren.

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

Antwoord 14

De onderstaande code doet het werk voor het converteren van ms naar min:secs met [m:ss] formaat

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]

Antwoord 15

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

Antwoord 16

Dit is gerelateerd aan een vorige post, maar naar mijn mening was de voorgestelde oplossing niet helemaal goed.
Om een ​​juiste conversie te realiseren, is dit wat moet worden geïmpteerd:

long time_millis = 1926546
int minutes = time_millis / 1000 / 60
int seconds = ((int)(time_millis / 1000) % 60) #important that this division is cast to an int
println "Build time: $minutes minutes $seconds seconds"

Antwoord 17

Hier is een eenvoudige oplossing.
Voorbeeld gesprekken die in elke methode kunnen worden gebruikt:

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

• StopWatch.displayDiff();geeft het verschil in minuten en seconden weer tussen starten en stoppen. (verstreken tijd)

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