Convert seconds value to hours minutes seconds?

I've been trying to convert a value of seconds (in a BigDecimal variable) to a string in an editText like "1 hour 22 minutes 33 seconds" or something of the kind.

I've tried this:

String sequenceCaptureTime = "";
BigDecimal roundThreeCalc = new BigDecimal("0");
BigDecimal hours = new BigDecimal("0");
BigDecimal myremainder = new BigDecimal("0");
BigDecimal minutes = new BigDecimal("0");
BigDecimal seconds = new BigDecimal("0");
BigDecimal var3600 = new BigDecimal("3600");
BigDecimal var60 = new BigDecimal("60");

(I have a roundThreeCalc which is the value in seconds so I try to convert it here.)

hours = (roundThreeCalc.divide(var3600));
myremainder = (roundThreeCalc.remainder(var3600));
minutes = (myremainder.divide(var60));
seconds = (myremainder.remainder(var60));
sequenceCaptureTime =  hours.toString() + minutes.toString() + seconds.toString();

Then I set the editText to sequnceCaptureTime String. But that didn't work. It force closed the app every time. I am totally out of my depth here, any help is greatly appreciated. Happy coding!

Is it necessary to use a BigDecimal? If you don't have to, I'd use an int or long for seconds, and it would simplify things a little bit:

hours = totalSecs / 3600;
minutes = (totalSecs % 3600) / 60;
seconds = totalSecs % 60;

timeString = String.format("%02d:%02d:%02d", hours, minutes, seconds);

You might want to pad each to make sure they're two digit values(or whatever) in the string, though.

DateUtils.formatElapsedTime(long), formats an elapsed time in the form "MM:SS" or "H:MM:SS" . It returns the String you are looking for. You can find the documentation here

You should have more luck with

hours = roundThreeCalc.divide(var3600, BigDecimal.ROUND_FLOOR);
myremainder = roundThreeCalc.remainder(var3600);
minutes = myremainder.divide(var60, BigDecimal.ROUND_FLOOR);
seconds = myremainder.remainder(var60);

This will drop the decimal values after each division.

Edit: If that didn't work, try this. (I just wrote and tested it)

public static int[] splitToComponentTimes(BigDecimal biggy)
{
	long longVal = biggy.longValue();
	int hours = (int) longVal / 3600;
	int remainder = (int) longVal - hours * 3600;
	int mins = remainder / 60;
	remainder = remainder - mins * 60;
	int secs = remainder;

	int[] ints = {hours , mins , secs};
	return ints;
}

Something really helpful in Java 8

import java.time.LocalTime;

private String ConvertSecondToHHMMSSString(int nSecondTime) {
	return LocalTime.MIN.plusSeconds(nSecondTime).toString();
}

Here is the working code:

private String getDurationString(int seconds) {
	
	int hours = seconds / 3600;
	int minutes = (seconds % 3600) / 60;
	seconds = seconds % 60;
	
	return twoDigitString(hours) + " : " + twoDigitString(minutes) + " : " + twoDigitString(seconds);
}

private String twoDigitString(int number) {
	
	if (number == 0) {
		return "00";
	}
	
	if (number / 10 == 0) {
		return "0" + number;
	}
	
	return String.valueOf(number);
}

I prefer java's built in TimeUnit library

long seconds = TimeUnit.MINUTES.toSeconds(8);

private String ConvertSecondToHHMMString(int secondtTime)
{
  TimeZone tz = TimeZone.getTimeZone("UTC");
  SimpleDateFormat df = new SimpleDateFormat("HH:mm:ss");
  df.setTimeZone(tz);
  String time = df.format(new Date(secondtTime*1000L));
	    	    
  return time;

}

This is my simple solution:

String secToTime(int sec) {
    int seconds = sec % 60;
    int minutes = sec / 60;
    if (minutes >= 60) {
        int hours = minutes / 60;
        minutes %= 60;
        if( hours >= 24) {
			int days = hours / 24;
			return String.format("%d days %02d:%02d:%02d", days,hours%24, minutes, seconds);
		}
		return String.format("%02d:%02d:%02d", hours, minutes, seconds);
	}
	return String.format("00:%02d:%02d", minutes, seconds);
}

Test Results:

Result: 00:00:36 - 36
Result: 01:00:07 - 3607
Result: 6313 days 12:39:05 - 545488745

If you want the units h, min and sec for a duration you can use this:

public static String convertSeconds(int seconds) {
    int h = seconds/ 3600;
    int m = (seconds % 3600) / 60;
    int s = seconds % 60;
    String sh = (h > 0 ? String.valueOf(h) + " " + "h" : "");
    String sm = (m < 10 && m > 0 && h > 0 ? "0" : "") + (m > 0 ? (h > 0 && s == 0 ? String.valueOf(m) : String.valueOf(m) + " " + "min") : "");
    String ss = (s == 0 && (h > 0 || m > 0) ? "" : (s < 10 && (h > 0 || m > 0) ? "0" : "") + String.valueOf(s) + " " + "sec");
    return sh + (h > 0 ? " " : "") + sm + (m > 0 ? " " : "") + ss;
}

int seconds = 3661;
String duration = convertSeconds(seconds);

That's a lot of conditional operators. The method will return those strings:

0    -> 0 sec
5    -> 5 sec
60   -> 1 min
65   -> 1 min 05 sec
3600 -> 1 h
3601 -> 1 h 01 sec
3660 -> 1 h 01
3661 -> 1 h 01 min 01 sec
108000 -> 30 h

I like to keep things simple therefore:

	int tot_seconds = 5000;
	int hours = tot_seconds / 3600;
	int minutes = (tot_seconds % 3600) / 60;
	int seconds = tot_seconds % 60;

	String timeString = String.format("%02d Hour %02d Minutes %02d Seconds ", hours, minutes, seconds);

	System.out.println(timeString);

The result will be: 01 Hour 23 Minutes 20 Seconds

A nice and easy way to do it using GregorianCalendar

Import these into the project:

import java.util.GregorianCalendar;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.Scanner;

And then:

Scanner s = new Scanner(System.in);

System.out.println("Seconds: ");
int secs = s.nextInt();
    
GregorianCalendar cal = new GregorianCalendar(0,0,0,0,0,secs);
Date dNow = cal.getTime();
SimpleDateFormat ft = new SimpleDateFormat("HH 'hours' mm 'minutes' ss 'seconds'");
System.out.println("Your time: " + ft.format(dNow));

This Code Is working Fine :

txtTimer.setText(String.format("%02d:%02d:%02d",(SecondsCounter/3600), ((SecondsCounter % 3600)/60), (SecondsCounter % 60)));

Duration from java.time

	BigDecimal secondsValue = BigDecimal.valueOf(4953);
	if (secondsValue.compareTo(BigDecimal.valueOf(Long.MAX_VALUE)) > 0) {
		System.out.println("Seconds value " + secondsValue + " is out of range");
	} else {
		Duration dur = Duration.ofSeconds(secondsValue.longValueExact());
		long hours = dur.toHours();
		int minutes = dur.toMinutesPart();
		int seconds = dur.toSecondsPart();
		
		System.out.format("%d hours %d minutes %d seconds%n", hours, minutes, seconds);
	}

Output from this snippet is:

> 1 hours 22 minutes 33 seconds

If there had been a non-zero fraction of second in the BigDecimal this code would not have worked as it stands, but you may be able to modify it. The code works in Java 9 and later. In Java 8 the conversion from Duration into hours minutes and seconds is a bit more wordy, see the link at the bottom for how. I am leaving to you to choose the correct singular or plural form of the words (hour or hours, etc.).

Links

• Oracle tutorial: Date Time explaining how to use java.time.
• Answer by lauhub showing the conversion from a Duration to days, hours, minutes and seconds in Java 8.

for just minutes and seconds use this

String.format("%02d:%02d", (seconds / 3600 * 60 + ((seconds % 3600) / 60)), (seconds % 60))

Here's my function to address the problem:

public static String getConvertedTime(double time){

    double h,m,s,mil;

    mil = time % 1000;
    s = time/1000;
    m = s/60;
    h = m/60;
    s = s % 60;
    m = m % 60;
    h = h % 24;

    return ((int)h < 10 ? "0"+String.valueOf((int)h) : String.valueOf((int)h))+":"+((int)m < 10 ? "0"+String.valueOf((int)m) : String.valueOf((int)m))
            +":"+((int)s < 10 ? "0"+String.valueOf((int)s) : String.valueOf((int)s))
            +":"+((int)mil > 100 ? String.valueOf((int)mil) : (int)mil > 9 ? "0"+String.valueOf((int)mil) : "00"+String.valueOf((int)mil));
}

I use this:

 public String SEG2HOR( long lnValue) {    	//OK
    	String lcStr = "00:00:00";
    	String lcSign = (lnValue>=0 ? " " : "-");
    	lnValue = lnValue * (lnValue>=0 ? 1 : -1); 
    	
    	if (lnValue>0) {	    	 	
	    	long lnHor  = (lnValue/3600);
	    	long lnHor1 = (lnValue % 3600);
	    	long lnMin  = (lnHor1/60);
	    	long lnSec  = (lnHor1 % 60);  	    	
	    	
	    	  	    	lcStr = lcSign + ( lnHor < 10 ? "0": "") + String.valueOf(lnHor) +":"+
	    					  ( lnMin < 10 ? "0": "") + String.valueOf(lnMin) +":"+
	    					  ( lnSec < 10 ? "0": "") + String.valueOf(lnSec) ;
    	}
    	
    	return lcStr;        	
    }

I know this is pretty old but in java 8:

LocalTime.MIN.plusSeconds(120).format(DateTimeFormatter.ISO_LOCAL_TIME)

I use this in python to convert a float representing seconds to hours, minutes, seconds, and microseconds. It's reasonably elegant and is handy for converting to a datetime type via strptime to convert. It could also be easily extended to longer intervals (weeks, months, etc.) if needed.

    def sectohmsus(seconds):
        x = seconds
        hmsus = []
        for i in [3600, 60, 1]:  # seconds in a hour, minute, and second
            hmsus.append(int(x / i))
            x %= i
        hmsus.append(int(round(x * 1000000)))  # microseconds
        return hmsus  # hours, minutes, seconds, microsecond

i have tried the best way and less code but may be it is little bit difficult to understand how i wrote my code but if you good at maths it is so easy

import java.util.Scanner;

class hours {

public static void main(String[] args) {
	Scanner input = new Scanner(System.in);
	double s;
	

	System.out.println("how many second you have ");
	s =input.nextInt();



	 double h=s/3600;
	 int h2=(int)h;

	 double h_h2=h-h2;
	 double m=h_h2*60;
	 int m1=(int)m;

	 double m_m1=m-m1;
	 double m_m1s=m_m1*60;






	 System.out.println(h2+" hours:"+m1+" Minutes:"+Math.round(m_m1s)+" seconds");
	 
	



}

}

more over it is accurate !

With Java 8, you can easily achieve time in String format from long seconds like,

LocalTime.ofSecondOfDay(86399L)

Here, given value is max allowed to convert (upto 24 hours) and result will be

23:59:59

Pros : 1) No need to convert manually and to append 0 for single digit

Cons : work only for up to 24 hours

Tough there are yet many correct answers and an accepted one, if you want a more handmade and systematized way to do this, I suggest something like this:

/**
 * Factors for converting seconds in minutes, minutes in hours, etc.
 */
private static int[] FACTORS = new int[] {
    60, 60, 24, 7
};

/**
 * Names of each time unit.
 * The length of this array needs to be FACTORS.length + 1.
 * The last one is the name of the remainder after
 * obtaining each component.
 */
private static String[] NAMES = new String[] {
    "second", "minute", "hour", "day", "week"
};

/**
 * Checks if quantity is 1 in order to use or not the plural.
 */
private static String quantityToString(int quantity, String name) {
    if (quantity == 1) {
        return String.format("%d %s", quantity, name);
    }
    return String.format("%d %ss", quantity, name);
}

/**
 * The seconds to String method.
 */
private static String secondsToString(int seconds) {
    List<String> components = new ArrayList<>();

    /**
     * Obtains each component and stores only if is not 0.
     */
    for (int i = 0; i < FACTORS.length; i++) {
        int component = seconds % FACTORS[i];
        seconds /= FACTORS[i];
        if (component != 0) {
            components.add(quantityToString(component, NAMES[i]));
        }
    }
    
    /**
     * The remainder is the last component.
     */
    if (seconds != 0) {
        components.add(quantityToString(seconds, NAMES[FACTORS.length]));
    }
    
    /**
     * We have the non-0 components in reversed order.
     * This could be extracted to another method.
     */
    StringBuilder builder = new StringBuilder();
    for (int i = components.size() - 1; i >= 0; i--) {
        if (i == 0 && components.size() > 1) {
            builder.append(" and ");
        } else if (builder.length() > 0) {
            builder.append(", ");
        }
        builder.append(components.get(i));
    }
    
    return builder.toString();
}

The result is as following:

System.out.println(secondsToString(5_000_000)); // 8 weeks, 1 day, 20 hours, 53 minutes and 20 seconds
System.out.println(secondsToString(500_000)); // 5 days, 18 hours, 53 minutes and 20 seconds
System.out.println(secondsToString(60*60*24)); // 1 day
System.out.println(secondsToString(2*60*60*24 + 3*60)); // 2 days and 3 minutes
System.out.println(secondsToString(60*60*24 + 3 * 60 * 60 + 53)); // 1 day, 3 hours and 53 seconds