'how to show milliseconds in days:hours:min:seconds
This is what I have at the moment
Seconds = (60 - timeInMilliSeconds / 1000 % 60);
Minutes = (60 - ((timeInMilliSeconds / 1000) / 60) %60);
which I feel is correct. for hours and days should it be like -
Hours = ((((timeInMilliSeconds / 1000) / 60) / 60) % 24);
Days = ((((timeInMilliSeconds / 1000) / 60) / 60) / 24) % 24;
and then-
TextView.SetText("Time left:" + Days + ":" + Hours + ":" + Minutes + ":" + Seconds);
but my hours and days are coming out to be incorrect
Solution 1:[1]
SimpleDateFormat is your friend! (I just discovered it today, it's awesome.)
SimpleDateFormat formatter = new SimpleDateFormat("dd:HH:mm:ss", Locale.UK);
Date date = new Date(timeInMilliSeconds);
String result = formatter.format(date);
Solution 2:[2]
Hi, how about this code ?
example)
0 ms -> 0 ms
846 ms -> 846ms
1,000 ms -> 1s
1,034 ms -> 1s 34ms
60,000 ms -> 1m
94,039 ms -> 1m 34s 39ms
3,600,000 ms -> 1h
61,294,039 ms -> 17h 1m 34s 39ms
86,400,000 ms -> 1d
406,894,039 ms -> 4d 17h 1m 34s 39ms
31,536,000,000 ms -> 1y
50,428,677,591 ms -> 1y 218d 15h 57m 57s 591ms
50,428,677,591 ns -> 50s 428ms 677us 591ns
50,428,677,591 us -> 14h 28s 677ms 591us
50,428,677,591 ms -> 1y 218d 15h 57m 57s 591ms
50,428,677,591 s -> 1599y 30d 5h 59m 51s
50,428,677,591 m -> 95944y 354d 23h 51m
50,428,677,591 h -> 5756698y 129d 15h
50,428,677,591 d -> 138160760y 191d
/*
* Copyright 2018 Park Jun-Hong_(fafanmama_at_naver_com)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
*
* This file is generated under this project, "open-commons-core".
*
* Date : 2018. 1. 9. ?? 1:36:33
*
* Author: Park_Jun_Hong_(fafanmama_at_naver_com)
*
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
/**
*
* @since 2018. 1. 9.
* @author Park_Jun_Hong_(fafanmama_at_naver_com)
*/
public class TimeUtils {
private static final TimeUnitInfo[] TIME_UNIT_INFO = new TimeUnitInfo[] { //
new TimeUnitInfo(TimeUnit.NANOSECONDS, "ns") //
, new TimeUnitInfo(TimeUnit.MICROSECONDS, "us") //
, new TimeUnitInfo(TimeUnit.MILLISECONDS, "ms") //
, new TimeUnitInfo(TimeUnit.SECONDS, "s") //
, new TimeUnitInfo(TimeUnit.MINUTES, "m") //
, new TimeUnitInfo(TimeUnit.HOURS, "h") //
, new TimeUnitInfo(TimeUnit.DAYS, "d") //
};
private static final Map<TimeUnit, String> UNIT_STR = new HashMap<>();
static {
for (TimeUnitInfo tui : TIME_UNIT_INFO) {
UNIT_STR.put(tui.unit, tui.unitStr);
}
}
private static final Function<TimeUnit, TimeUnitInfo[]> FN_TIME_UNITS = unit -> {
ArrayList<TimeUnitInfo> units = new ArrayList<>();
for (TimeUnitInfo tui : TIME_UNIT_INFO) {
if (tui.unit.ordinal() >= unit.ordinal()) {
units.add(tui);
}
}
return units.toArray(new TimeUnitInfo[] {});
};
/** discard none. */
public static final int DC_NONE = 0x00;
/** discard under nanoseconds */
public static final int DC_NANO = 0x01;
/** discard under microseconds */
public static final int DC_MICRO = DC_NANO << 1;
/** discard under milliseconds */
public static final int DC_MILLI = DC_MICRO << 1;
/** discard under seconds */
public static final int DC_SECOND = DC_MILLI << 1;
/** discard under minutes */
public static final int DC_MINUTE = DC_SECOND << 1;
/** discard under hours */
public static final int DC_HOUR = DC_MINUTE << 1;
/** discard under days */
public static final int DC_DAY = DC_HOUR << 1;
// prevent to create an instance.
private TimeUtils() {
}
public static void main(String[] args) {
long[] times = new long[] { 0, 846, 1000, 1034, 60000, 94039, 3600000, 61294039, 86400000, 406894039, 31536000000L, 50428677591L };
for (long time : times) {
System.out.println(String.format("%20s %-2s -> %s", String.format("%,d", time), "ms", toFormattedString(time, TimeUnit.MILLISECONDS)));
}
System.out.println("=================================");
long time = 50428677591L;
for (TimeUnitInfo tui : TIME_UNIT_INFO) {
System.out.println(String.format("%20s %-2s -> %s", String.format("%,d", time), tui.unitStr, toFormattedString(time, tui.unit)));
}
}
private static long mod(long time, TimeUnit unit) {
switch (unit) {
case NANOSECONDS: // to nanosecond
case MILLISECONDS: // to microsecond
case MICROSECONDS: // to millsecond
return time % 1000;
case SECONDS: // to second
return time % 60;
case MINUTES: // to minute
return time % 60;
case HOURS: // to hour
return time % 24;
case DAYS: // to day
return time % 365;
default:
throw new IllegalArgumentException(unit.toString());
}
}
/**
*
* <br>
*
* <pre>
* [????]
* ?? | ??? | ??
* ------------------------------------------
* 2018. 1. 9. ??? ?? ??
* </pre>
*
* @param timeBuf
* @param time
* @param unit
*
* @author Park_Jun_Hong_(fafanmama_at_naver_com)
* @since 2018. 1. 9.
*/
private static void prependTimeAndUnit(StringBuffer timeBuf, long time, String unit) {
if (time < 1) {
return;
}
if (timeBuf.length() > 0) {
timeBuf.insert(0, " ");
}
timeBuf.insert(0, unit);
timeBuf.insert(0, time);
}
/**
* Provide the Millisecond time value in {year}y {day}d {hour}h {minute}m {second}s {millisecond}ms {nanoseconds}ns.
* <br>
* Omitted if there is no value for that unit.
*
* @param time
* time value.
* @param timeUnit
* a unit of input time value.
* @return
*
* @since 2018. 1. 9.
*/
public static String toFormattedString(long time, TimeUnit timeUnit) {
// if zero ...
if (time < 1) {
return "0 " + UNIT_STR.get(timeUnit);
}
StringBuffer timeBuf = new StringBuffer();
long mod = 0L;
long up = time;
for (TimeUnitInfo unit : FN_TIME_UNITS.apply(timeUnit)) {
mod = mod(up, unit.unit);
prependTimeAndUnit(timeBuf, mod, unit.unitStr);
up = up(up, unit.unit);
if (up < 1) {
return timeBuf.toString();
}
}
prependTimeAndUnit(timeBuf, up, "y");
return timeBuf.toString();
}
private static long up(long time, TimeUnit unit) {
switch (unit) {
case NANOSECONDS: // to microsecond & above
case MILLISECONDS: // to millsecond & above
case MICROSECONDS: // to second & above
return time / 1000;
case SECONDS: // to minute & above
return time / 60;
case MINUTES: // to hour & above
return time / 60;
case HOURS: // to day & above
return time / 24;
case DAYS: // to year & above
return time / 365;
default:
throw new IllegalArgumentException(unit.toString());
}
}
private static class TimeUnitInfo {
private final TimeUnit unit;
private final String unitStr;
public TimeUnitInfo(TimeUnit unit, String unitStr) {
this.unit = unit;
this.unitStr = unitStr;
}
}
}
Solution 3:[3]
To format elapsed/remaining times in android, use android.text.format.DateUtils, in particular, getRelativeTimeSpanString and formatElapsedTime.
Solution 4:[4]
You can also use the joda-time API (http://joda.org/joda-time/)
"The class DateTimeFormat provides a single method forPattern(String) that supports formatting by pattern. These "pattern-based" formatters provide a similar approach to that of SimpleDateFormat."
LocalDate date = LocalDate.now();
DateTimeFormatter fmt = DateTimeFormat.forPattern("d MMMM, yyyy");
String str = date.toString(fmt);
Solution 5:[5]
Here is a simple JS function
function simplifiedMilliseconds(milliseconds) {
const totalSeconds = parseInt(Math.floor(milliseconds / 1000));
const totalMinutes = parseInt(Math.floor(totalSeconds / 60));
const totalHours = parseInt(Math.floor(totalMinutes / 60));
const days = parseInt(Math.floor(totalHours / 24));
const seconds = parseInt(totalSeconds % 60);
const minutes = parseInt(totalMinutes % 60);
const hours = parseInt(totalHours % 24);
let time = '1s';
if (days > 0) {
time = `${days}d:${hours}h:${minutes}m:${seconds}s`;
} else if (hours > 0) {
time = `${hours}h:${minutes}m:${seconds}s`;
} else if (minutes > 0) {
time = `${minutes}m:${seconds}s`;
} else if (seconds > 0) {
time = `${seconds}s`;
}
return time;
}
Solution 6:[6]
java.time
I recommend you use java.time.Duration which is modelled on ISO-8601 standards and was introduced with Java-8 as part of JSR-310 implementation. With Java-9 some more convenience methods were introduced.
import java.time.Duration;
public class Main {
public static void main(String[] args) {
// Given milliseconds e.g. milliseconds from the epoch
long millis = System.currentTimeMillis();
Duration duration = Duration.ofMillis(millis);
// Duration in default format
System.out.println(duration);
// Custom format
// ####################################Java-8####################################
String formattedElapsedTime = String.format("%d:%02d:%02d:%02d", duration.toDays(), duration.toHours() % 24,
duration.toMinutes() % 60, duration.toSeconds() % 60);
System.out.println("Duration (days:hours:min:seconds): " + formattedElapsedTime);
// ##############################################################################
// ####################################Java-9####################################
formattedElapsedTime = String.format("%d:%02d:%02d:%02d", duration.toDaysPart(), duration.toHoursPart(),
duration.toMinutesPart(), duration.toSecondsPart());
System.out.println("Duration (days:hours:min:seconds): " + formattedElapsedTime);
// ##############################################################################
}
}
Output:
PT448255H41M9.125S
Duration (days:hours:min:seconds): 18677:07:41:09
Duration (days:hours:min:seconds): 18677:07:41:09
Note: For any reason, if you have to stick to Java 6 or Java 7, you can use ThreeTen-Backport which backports most of the java.time functionality to Java 6 & 7. If you are working for an Android project and your Android API level is still not compliant with Java-8, check Java 8+ APIs available through desugaring and How to use ThreeTenABP in Android Project.
Solution 7:[7]
to solve your question try the following java class (with immutable instances)
package adrjx.utils.time;
public class VRDecodedTimePeriodMillis
{
// instance data
private int theMillisecs = 0;
private int theSeconds = 0;
private int theMinutes = 0;
private int theHours = 0;
private int theDays = 0;
// init
public VRDecodedTimePeriodMillis (long aTimePeriodMillis)
{
long aSeconds = aTimePeriodMillis / 1000;
long aMinutes = aSeconds / 60;
long aHours = aMinutes / 60;
long aDays = aHours / 24;
this.theMillisecs = (int)(aTimePeriodMillis % 1000);
this.theSeconds = (int)(aSeconds % 60);
this.theMinutes = (int)(aMinutes % 60);
this.theHours = (int)(aHours % 24);
this.theDays = (int)(aDays);
// done
}
// accessors
public int getMillisecs() { return this.theMillisecs; }
public int getSeconds() { return this.theSeconds; }
public int getMinutes() { return this.theMinutes; }
public int getHours() { return this.theHours; }
public int getDays() { return this.theDays; }
}
that's all folks ...
Solution 8:[8]
java.util.concurrent.TimeUnit to the rescue:
long remainingMillis = 1076232425L; // Your value comes here.
long days = TimeUnit.MILLISECONDS.toDays(remainingMillis);
long daysMillis = TimeUnit.DAYS.toMillis(days);
long hours = TimeUnit.MILLISECONDS.toHours(remainingMillis - daysMillis);
long hoursMillis = TimeUnit.HOURS.toMillis(hours);
long minutes = TimeUnit.MILLISECONDS.toMinutes(remainingMillis - daysMillis - hoursMillis);
long minutesMillis = TimeUnit.MINUTES.toMillis(minutes);
long seconds = TimeUnit.MILLISECONDS.toSeconds(remainingMillis - daysMillis - hoursMillis - minutesMillis);
String resultString = days + " day(s) " + hours + " hour(s) " + minutes + " minute(s) " + seconds + " second(s)";
Solution 9:[9]
Kotlin way
fun getTripDuration(durationStr: String): String {
val totalSeconds = durationStr.toDouble()
val totalMinutes = floor(totalSeconds / 60)
val totalHours = floor(totalMinutes / 60)
val days = floor(totalHours / 24).toLong()
val minutes = (totalMinutes % 60).toLong()
val hours = (totalHours % 24).toLong()
Timber.d("$days Days $hours Hours $minutes Minutes")
var durationInWords = ""
if (days > 1L) {
durationInWords = durationInWords.plus("$days days ")
} else if (days == 1L) {
durationInWords = durationInWords.plus("$days day ")
}
if (hours > 1L) {
durationInWords = durationInWords.plus("$hours hours ")
} else if (hours == 1L) {
durationInWords = durationInWords.plus("$hours hour ")
}
if (minutes > 1L) {
durationInWords = durationInWords.plus("$minutes mins")
} else if (minutes == 1L) {
durationInWords = durationInWords.plus("$minutes min")
}
if (durationInWords.isEmpty()) {
durationInWords = durationInWords.plus("$minutes min")
}
return durationInWords
}
Sources
This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.
Source: Stack Overflow