X milliseconds = X / 1000 seconds = (X / 1000) / 60 minutes

If you have 100,000 milliseconds, divide this value by 1,000 and you're left with 100 seconds. Now 100 / 60 = 1.666~ minutes, but fractional minutes have no value, so: do 100 % 60 = 40 seconds to find the remainder, then integer division 100 / 60 = 1 minute, with 40 seconds remainder. Answer: 1 minute, 40 seconds.

After converting millis to seconds (by dividing by 1000), you can use / 60 to get the minutes value, and % 60 (remainder) to get the "seconds in minute" value.

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

This is just basic math. 1000 milliseconds=1 second and 60000 milliseconds = 1 minute; So just do,

int seconds=(millis/1000)%60;


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

I would suggest using TimeUnit. You can use it like this:

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

I don't think Java 1.5 support concurrent TimeUnit. Otherwise, I would suggest for TimeUnit. Below is based on pure math approach.

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


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

Here is a simple solution. Example calls that could be used in any method:

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

• StopWatch.displayDiff(); displays difference in minutes and seconds between start and stop. (elapsed time)

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

tl;dr

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

Java 9 and later

In Java 9 and later, create a Duration and call the to…Part methods. In this case: toMinutesPart and toSecondsPart.

Capture the start & stop of your stopwatch.

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

Represent elapsed time in a Duration object.

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

Interrogate for each part, the minutes and the seconds.

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

You might also want to see if your stopwatch ran expectedly long.

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

Java 8

In Java 8, the Duration class lacks to…Part methods. You will need to do math as shown in the other Answers.

long entireDurationAsSeconds = d.getSeconds();

Or let Duration do the math.

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

See live code in IdeOne.com.

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

d.toString(): PT2M15S

d.getSeconds(): 135

Elapsed: 2M 15S

Resolution

FYI, the resolution of now methods changed between Java 8 and Java 9. See this Question.

• Java 9 captures the moment with a resolution as fine as nanoseconds. Resolution depends on capability of your computer’s hardware. I see microseconds (six digits of decimal fraction) on MacBook Pro Retina with macOS Sierra.
• Java 8 captures the moment only up to milliseconds. The implementation of Clock is limited to a resolution of milliseconds. So you can store values in nanoseconds but only capture them in milliseconds.

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.

To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

Where to obtain the java.time classes?

• Java SE 8, Java SE 9, Java SE 10, Java SE 11, and later - Part of the standard Java API with a bundled implementation.
  • Java 9 adds some minor features and fixes.
• Java SE 6 and Java SE 7
  • Most 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.
  • For earlier Android (<26), the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP….

Here is the full program

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


}
}

I found this program here "Link" there it is explained in detail.

I was creating a mp3 player app for android, so I did it like this to get current time and duration

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

To convert time in millis directly to minutes: second format you can use this

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

This will return a string with time in proper formatting. It worked for me.

To get actual hour, minute and seconds as appear on watch try this code

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

You can try proceeding this way:

Pass ms value from

Long ms = watch.getTime();

to

getDisplayValue(ms)

Kotlin implementation:

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

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

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

You can easily convert miliseconds into seconds, minutes and hours.

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

Below code does the work for converting ms to min:secs with [m:ss] format

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]

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

Shorter Form!

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

Testing

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

Output

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

This is related to a previous post, but in my opinion the solution proposed wasn't quite right.
In order to realize a correct conversion, this is what should be implemnted:

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"

Apache Commons Lang class DurationFormatUtils. This class has some standard formats out of the box but also supports custom formats.

String result = DurationFormatUtils.formatDuration(millis, "mm:ss.SSS' sec.'");

I need to convert millisecond to minute and second for timer so I used this code.

private String getTime(long millisecond) {
    

long min = TimeUnit.MILLISECONDS.toMinutes(millisecond);
long sec = TimeUnit.MILLISECONDS.toSeconds(millisecond) -
TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millisecond));


String time = min + ":" + sec;
return time;
}

for revers, each minute equals 60,000 millisecond and each second equals 1000 millisecond. So :

 long millisecond = minutes * 60000;
long millisecond = seconds * 1000;

or

 long millisecond = TimeUnit.SECONDS.toMillis(seconds);

You can convert milliseconds to hours, minutes and seconds using this method

public String timeConversion(Long millie) {
if (millie != null) {
long seconds = (millie / 1000);
long sec = seconds % 60;
long min = (seconds / 60) % 60;
long hrs = (seconds / (60 * 60)) % 24;
if (hrs > 0) {
return String.format("%02d:%02d:%02d", hrs, min, sec);
} else {
return String.format("%02d:%02d", min, sec);
}
} else {
return null;
}
}

then use this method like this

videoDuration.setText(timeConversion((long) milliSecondsHere));

In Kotlin

fun timeConverter(millie: Long): String {
return run {
val seconds: Long = millie / 2000
val sec = seconds % 60
val min = seconds / 60 % 60
val hrs = seconds / (60 * 60) % 24
return if (hrs > 0) {
String.format("%02d:%02d:%02d", hrs, min, sec)
} else {
String.format("%02d:%02d", min, sec)
}
}