Java 如何将毫秒转换为“毫秒”；hh:mm:ss“；格式？_Java_Time Format_Countdowntimer

Java 如何将毫秒转换为“毫秒”；hh:mm:ss“；格式？

java

Java 如何将毫秒转换为“毫秒”；hh:mm:ss“；格式？,java,time-format,countdowntimer,Java,Time Format,Countdowntimer,我很困惑。在无意中发现了这个线程之后，我试图弄明白如何格式化一个倒计时计时器，它的格式是hh:mm:ss 这是我的尝试- //hh:mm:ss String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis), TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.MINUTES.toMinutes(TimeUnit.MILLISECONDS.to

我很困惑。在无意中发现了这个线程之后，我试图弄明白如何格式化一个倒计时计时器，它的格式是

hh:mm:ss

这是我的尝试-

//hh:mm:ss
String.format("%02d:%02d:%02d", 
    TimeUnit.MILLISECONDS.toHours(millis),
    TimeUnit.MILLISECONDS.toMinutes(millis) - 
    TimeUnit.MINUTES.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
    TimeUnit.MILLISECONDS.toSeconds(millis) - 
    TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

因此，当我尝试像

3600000ms

这样的值时，我得到了

01:59:00

，这是错误的，因为它应该是

01:00:00

。显然我的逻辑有问题，但目前我看不出是什么

有人能帮忙吗

编辑-

修好了。下面是将毫秒格式化为

hh:mm:ss

格式的正确方法-

//hh:mm:ss
String.format("%02d:%02d:%02d", 
    TimeUnit.MILLISECONDS.toHours(millis),
    TimeUnit.MILLISECONDS.toMinutes(millis) - 
    TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
    TimeUnit.MILLISECONDS.toSeconds(millis) - 
    TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))));

问题是这个

TimeUnit.MINUTES.toMinutes（TimeUnit.millises.toHours（millis））

。应该是这样的

TimeUnit.HOURS.toMinutes（TimeUnit.millises.toHours（millis））

。

通用方法非常简单：

public static String convertSecondsToHMmSs(long seconds) {
    long s = seconds % 60;
    long m = (seconds / 60) % 60;
    long h = (seconds / (60 * 60)) % 24;
    return String.format("%d:%02d:%02d", h,m,s);
}

你真的很接近：

您正在使用分钟而不是小时将小时转换为毫秒

顺便说一句，我喜欢你使用

TimeUnit

API:）

下面是一些测试代码：

public static void main(String[] args) throws ParseException {
    long millis = 3600000;
    String hms = String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis),
            TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
            TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
    System.out.println(hms);
}

输出：

01:00:00

我意识到，通过使用模除法而不是减法，我的上述代码可以大大简化：

String hms = String.format("%02d:%02d:%02d", TimeUnit.MILLISECONDS.toHours(millis),
    TimeUnit.MILLISECONDS.toMinutes(millis) % TimeUnit.HOURS.toMinutes(1),
    TimeUnit.MILLISECONDS.toSeconds(millis) % TimeUnit.MINUTES.toSeconds(1));

仍然使用

TimeUnit

API处理所有魔法值，并给出完全相同的输出。

好吧，您可以尝试以下方法：

public String getElapsedTimeHoursMinutesSecondsString() {       
     long elapsedTime = getElapsedTime();  
     String format = String.format("%%0%dd", 2);  
     elapsedTime = elapsedTime / 1000;  
     String seconds = String.format(format, elapsedTime % 60);  
     String minutes = String.format(format, (elapsedTime % 3600) / 60);  
     String hours = String.format(format, elapsedTime / 3600);  
     String time =  hours + ":" + minutes + ":" + seconds;  
     return time;  
 }

要将毫秒转换为时间值（如果使用apache commons）：

DateFormat df = new SimpleDateFormat("HH:mm:ss");
String formatted = df.format(aDateObject);

DurationFormatUtils.formatDuration(timeInMS, "HH:mm:ss,SSS");

我试过了，如第一个答案所示。它起作用了，但是负让我感到困惑。Groovy给出了我的答案：

import static java.util.concurrent.TimeUnit.*

...

private static String formatElapsedTime(long millis) {

    int hrs = MILLISECONDS.toHours(millis) % 24
    int min = MILLISECONDS.toMinutes(millis) % 60
    int sec = MILLISECONDS.toSeconds(millis) % 60
    int mls = millis % 1000

    sprintf( '%02d:%02d:%02d (%03d)', [hrs, min, sec, mls])
}

四种实现的测试结果

必须对海量数据进行大量格式化，需要最佳性能，因此以下是（令人惊讶的）结果：

对于（int i=0；i<1000000；i++）{ 函数调用 }

持续时间：

组合格式化程序：196millis
格式化持续时间：272毫秒
apacheFormat:754毫秒

格式时间单位：2216毫秒

public static String apacheFormat(long millis) throws ParseException {
    return DurationFormatUtils.formatDuration(millis, "HH:mm:ss");
}

public static String formatTimeUnit(long millis) throws ParseException {
String formatted = String.format(
        "%02d:%02d:%02d",
        TimeUnit.MILLISECONDS.toHours(millis),
        TimeUnit.MILLISECONDS.toMinutes(millis)
                - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
        TimeUnit.MILLISECONDS.toSeconds(millis)
                - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
    return formatted;
}

public static String formatDuration(final long millis) {
    long seconds = (millis / 1000) % 60;
    long minutes = (millis / (1000 * 60)) % 60;
    long hours = millis / (1000 * 60 * 60);

    StringBuilder b = new StringBuilder();
    b.append(hours == 0 ? "00" : hours < 10 ? String.valueOf("0" + hours) : 
    String.valueOf(hours));
    b.append(":");
    b.append(minutes == 0 ? "00" : minutes < 10 ? String.valueOf("0" + minutes) :     
    String.valueOf(minutes));
    b.append(":");
    b.append(seconds == 0 ? "00" : seconds < 10 ? String.valueOf("0" + seconds) : 
    String.valueOf(seconds));
    return b.toString();
}

public static String combinationFormatter(final long millis) {
    long seconds = TimeUnit.MILLISECONDS.toSeconds(millis)
            - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis));
    long minutes = TimeUnit.MILLISECONDS.toMinutes(millis)
            - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis));
    long hours = TimeUnit.MILLISECONDS.toHours(millis);

    StringBuilder b = new StringBuilder();
    b.append(hours == 0 ? "00" : hours < 10 ? String.valueOf("0" + hours) : 
    String.valueOf(hours));
    b.append(":");
    b.append(minutes == 0 ? "00" : minutes < 10 ? String.valueOf("0" + minutes) : 
    String.valueOf(minutes));
        b.append(":");
    b.append(seconds == 0 ? "00" : seconds < 10 ? String.valueOf("0" + seconds) : 
    String.valueOf(seconds));
    return b.toString(); 
 }

公共静态字符串apacheFormat（长毫秒）引发异常{
返回持续时间formatUtils.formatDuration（毫秒，“HH:mm:ss”）；
}
公共静态字符串formatTimeUnit（长毫秒）引发异常{
String formatted=String.format(
“%02d:%02d:%02d”，
时间单位。毫秒。至小时（毫秒），
时间单位.毫秒.t分钟（毫秒）
-TimeUnit.HOURS.toMinutes（TimeUnit.millises.toHours（millis）），
时间单位。毫秒。至秒（毫秒）
-时间单位：分钟到秒（时间单位：毫秒到分钟（毫秒））；
返回格式；
}
公共静态字符串格式持续时间（最终长毫秒）{
长秒=（毫秒/1000）%60；
长分钟=（毫秒/（1000*60））%60；
长时间=毫秒/（1000*60*60）；
StringBuilder b=新的StringBuilder（）；
b、 追加（小时数==0？“00”：小时数<10？字符串。valueOf（“0”+小时数”）：
String.valueOf（小时））；
b、 附加（“：”）；
b、 追加（分钟==0？“00”：分钟<10？字符串。valueOf（“0”+分钟）：
String.valueOf（分钟）；
b、 附加（“：”）；
b、 追加（秒==0？“00”：秒<10？字符串。valueOf（“0”+秒）：
String.valueOf（秒））；
返回b.toString（）；
}
公共静态字符串组合格式化程序（最终长毫秒）{
长秒=时间单位。毫秒。到秒（毫秒）
-TimeUnit.MINUTES.toSeconds（TimeUnit.ms.toMinutes（毫秒））；
长分钟=时间单位。毫秒。分钟（毫秒）
-TimeUnit.HOURS.toMinutes（TimeUnit.millises.toHours（millis））；
长时间=时间单位。毫秒。到小时（毫秒）；
StringBuilder b=新的StringBuilder（）；
b、 追加（小时数==0？“00”：小时数<10？字符串。valueOf（“0”+小时数”）：
String.valueOf（小时））；
b、 附加（“：”）；
b、 追加（分钟==0？“00”：分钟<10？字符串。valueOf（“0”+分钟）：
String.valueOf（分钟）；
b、 附加（“：”）；
b、 追加（秒==0？“00”：秒<10？字符串。valueOf（“0”+秒）：
String.valueOf（秒））；
返回b.toString（）；
}

请参阅使用1200毫秒的输入。

下面的代码以两种方式进行转换

23:59:58:999至86398999

及

86398999至23:59:58:999

import java.util.concurrent.TimeUnit；
公共类时间实用程序{
公共静态void main（字符串[]args）{
长currentDateTime=System.currentTimeMillis（）；
字符串strTest=“23:59:58:999”；
系统输出打印项次（strTest）；
长l=strToMilli（strTest）；
系统输出打印LN（l）；
l+=1；
字符串str=毫字符串（l）；
系统输出打印项次（str）；
}
/**
*将时间字符串转换为等效的长毫秒
*
*@param strTime字符串格式为HH:MM:SS:MSMS，即“23:59:59:999”
*@返回长整数，如86399999
*/
公共静态长stromilli（字符串strTime）{
长回程=0；
字符串hour=strTime.substring（0,2）；
字符串min=strTime.substring（3,5）；
stringsec=strTime.substring（6,8）；
字符串milli=strTime.substring（9,12）；
int h=整数.parseInt（小时）；
int m=Integer.parseInt（最小值）；
int s=整数.parseInt（秒）；
int ms=整数.parseInt（毫）；
String strDebug=String.format（“%02d:%02d:%02d:%03d”，h、m、s、ms）；
//System.out.println（strDebug）；
长lH=h*60*60*1000；
长lM=m*60*1000；
长lS=s*1000；
retVal=lH+lM+lS+ms；
返回返回；
}
/**
*将时间（以毫秒为单位）转换为相应的字符串（以天为单位）
*翻滚从头开始23:59:59:999+1=00:00:00:000
*
*@param millis是与tim对应的毫秒数，即。
*34137999，可通过以下方式获得：；
*
*
public static String apacheFormat(long millis) throws ParseException {
    return DurationFormatUtils.formatDuration(millis, "HH:mm:ss");
}

public static String formatTimeUnit(long millis) throws ParseException {
String formatted = String.format(
        "%02d:%02d:%02d",
        TimeUnit.MILLISECONDS.toHours(millis),
        TimeUnit.MILLISECONDS.toMinutes(millis)
                - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
        TimeUnit.MILLISECONDS.toSeconds(millis)
                - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));
    return formatted;
}

public static String formatDuration(final long millis) {
    long seconds = (millis / 1000) % 60;
    long minutes = (millis / (1000 * 60)) % 60;
    long hours = millis / (1000 * 60 * 60);

    StringBuilder b = new StringBuilder();
    b.append(hours == 0 ? "00" : hours < 10 ? String.valueOf("0" + hours) : 
    String.valueOf(hours));
    b.append(":");
    b.append(minutes == 0 ? "00" : minutes < 10 ? String.valueOf("0" + minutes) :     
    String.valueOf(minutes));
    b.append(":");
    b.append(seconds == 0 ? "00" : seconds < 10 ? String.valueOf("0" + seconds) : 
    String.valueOf(seconds));
    return b.toString();
}

public static String combinationFormatter(final long millis) {
    long seconds = TimeUnit.MILLISECONDS.toSeconds(millis)
            - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis));
    long minutes = TimeUnit.MILLISECONDS.toMinutes(millis)
            - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis));
    long hours = TimeUnit.MILLISECONDS.toHours(millis);

    StringBuilder b = new StringBuilder();
    b.append(hours == 0 ? "00" : hours < 10 ? String.valueOf("0" + hours) : 
    String.valueOf(hours));
    b.append(":");
    b.append(minutes == 0 ? "00" : minutes < 10 ? String.valueOf("0" + minutes) : 
    String.valueOf(minutes));
        b.append(":");
    b.append(seconds == 0 ? "00" : seconds < 10 ? String.valueOf("0" + seconds) : 
    String.valueOf(seconds));
    return b.toString(); 
 }

// New date object from millis
Date date = new Date(millis);
// formattter 
SimpleDateFormat formatter= new SimpleDateFormat("HH:mm:ss.SSS");
formatter.setTimeZone(TimeZone.getTimeZone("UTC"));
// Pass date object
String formatted = formatter.format(date );

import java.util.concurrent.TimeUnit;

public class TimeUtility {

    public static void main(String[] args) {

        long currentDateTime = System.currentTimeMillis();

        String strTest = "23:59:58:999";
        System.out.println(strTest);

        long l = strToMilli(strTest);
        System.out.println(l);
        l += 1;
        String str = milliToString(l);
        System.out.println(str);
    }

    /**
     * convert a time string into the equivalent long milliseconds
     *
     * @param strTime string fomratted as HH:MM:SS:MSMS i.e. "23:59:59:999"
     * @return long integer like 86399999
     */
    public static long strToMilli(String strTime) {
        long retVal = 0;
        String hour = strTime.substring(0, 2);
        String min = strTime.substring(3, 5);
        String sec = strTime.substring(6, 8);
        String milli = strTime.substring(9, 12);
        int h = Integer.parseInt(hour);
        int m = Integer.parseInt(min);
        int s = Integer.parseInt(sec);
        int ms = Integer.parseInt(milli);

        String strDebug = String.format("%02d:%02d:%02d:%03d", h, m, s, ms);
        //System.out.println(strDebug);
        long lH = h * 60 * 60 * 1000;
        long lM = m * 60 * 1000;
        long lS = s * 1000;

        retVal = lH + lM + lS + ms;
        return retVal;
    }

    /**
     * convert time in milliseconds to the corresponding string, in case of day
     * rollover start from scratch 23:59:59:999 + 1 = 00:00:00:000
     *
     * @param millis the number of milliseconds corresponding to tim i.e.
     *               34137999 that can be obtained as follows;
     *               <p>
     *               long lH = h * 60 * 60 * 1000; //hour to milli
     *               <p>
     *               long lM = m * 60 * 1000; // minute to milli
     *               <p>
     *               long lS = s * 1000; //seconds to milli
     *               <p>
     *               millis = lH + lM + lS + ms;
     * @return a string formatted as HH:MM:SS:MSMS i.e. "23:59:59:999"
     */
    private static String milliToString(long millis) {

        long hrs = TimeUnit.MILLISECONDS.toHours(millis) % 24;
        long min = TimeUnit.MILLISECONDS.toMinutes(millis) % 60;
        long sec = TimeUnit.MILLISECONDS.toSeconds(millis) % 60;
        //millis = millis - (hrs * 60 * 60 * 1000); //alternative way
        //millis = millis - (min * 60 * 1000);
        //millis = millis - (sec * 1000);
        //long mls = millis ;
        long mls = millis % 1000;
        String toRet = String.format("%02d:%02d:%02d:%03d", hrs, min, sec, mls);
        //System.out.println(toRet);
        return toRet;
    }
}

String.format("%1$tH:%1$tM:%1$tS.%1$tL", millis);

String hms = String.format("%02d:%02d:%02d", millisLeft/(3600*1000),
                    millisLeft/(60*1000) % 60,
                    millisLeft/1000 % 60);

        String string = String.format("%02d:%02d:%02d.%03d",
            TimeUnit.MILLISECONDS.toHours(millisecend), TimeUnit.MILLISECONDS.toMinutes(millisecend) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millisecend)),
            TimeUnit.MILLISECONDS.toSeconds(millisecend) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millisecend)), millisecend - TimeUnit.SECONDS.toMillis(TimeUnit.MILLISECONDS.toSeconds(millisecend)));

 public String millsToDateFormat(long mills) {

    Date date = new Date(mills);
    DateFormat formatter = new SimpleDateFormat("HH:mm:ss");
    String dateFormatted = formatter.format(date);
    return dateFormatted; //note that it will give you the time in GMT+0
}

String myTime = String.format("%02d:%02d:%02d",
            TimeUnit.MILLISECONDS.toHours(millis),
            TimeUnit.MILLISECONDS.toMinutes(millis) -
                    TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)), // The change is in this line
            TimeUnit.MILLISECONDS.toSeconds(millis) -
                    TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

417474:44:19

String myTime =  String.format("%02d:%02d:%02d",
                //Hours
                TimeUnit.MILLISECONDS.toHours(millis) -
                        TimeUnit.DAYS.toHours(TimeUnit.MILLISECONDS.toDays(millis)),
                //Minutes
                TimeUnit.MILLISECONDS.toMinutes(millis) -
                        TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(millis)),
                //Seconds
                TimeUnit.MILLISECONDS.toSeconds(millis) -
                        TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis)));

18:44:19

   Date myDate = new Date(timeinMillis);
   SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
   String myTime = formatter.format(myDate);

    Duration timeLeft = Duration.ofMillis(3600000);
    String hhmmss = String.format("%02d:%02d:%02d", 
            timeLeft.toHours(), timeLeft.toMinutesPart(), timeLeft.toSecondsPart());
    System.out.println(hhmmss);

    long hours = timeLeft.toHours();
    timeLeft = timeLeft.minusHours(hours);
    long minutes = timeLeft.toMinutes();
    timeLeft = timeLeft.minusMinutes(minutes);
    long seconds = timeLeft.toSeconds();
    String hhmmss = String.format("%02d:%02d:%02d", hours, minutes, seconds);
    System.out.println(hhmmss);

val hours = String.format("%02d", TimeUnit.MILLISECONDS.toHours(milSecs))
val minutes = String.format("%02d",
                        TimeUnit.MILLISECONDS.toMinutes(milSecs) - TimeUnit.HOURS.toMinutes(TimeUnit.MILLISECONDS.toHours(milSecs)))
val seconds = String.format("%02d",
                        TimeUnit.MILLISECONDS.toSeconds(milSecs) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(milSecs)))

fun formatToDigitalClock(miliSeconds: Long): String {
        val hours = TimeUnit.MILLISECONDS.toHours(miliSeconds).toInt() % 24
        val minutes = TimeUnit.MILLISECONDS.toMinutes(miliSeconds).toInt() % 60
        val seconds = TimeUnit.MILLISECONDS.toSeconds(miliSeconds).toInt() % 60
        return when {
            hours > 0 -> String.format("%d:%02d:%02d", hours, minutes, seconds)
            minutes > 0 -> String.format("%02d:%02d", minutes, seconds)
            seconds > 0 -> String.format("00:%02d", seconds)
            else -> {
                "00:00"
            }
        }
    }