Convert length of time to appropriate unit

Question

I have a time, in seconds, which has the possibility to be very large. I wish to convert said time into the "appropriate" rounded, readable format.

I already have code which achieves this, however it's not very efficient (and contains a whole bunch of magic numbers):

String readable = decayTime + " minutes";
if(decayTime > 60)
{
    decayTime /= 60;
    readable = decayTime + " hours";

    if(decayTime > 24)
    {
        decayTime /= 24;
        readable = decayTime + " days";

        if(decayTime > 365)
        {
            decayTime /= 365;
            readable = decayTime + " years";

            if(decayTime > 1000000)
            {
                decayTime /= 1000000;
                readable = decayTime + "mn years";

                if(decayTime > 1000)
                {
                    decayTime /= 1000;
                    readable = decayTime + "bn years"; 
                }
            }
        }
    }

Apart from switching out the magic numbers, I can't personally think how to make it better.

What would be a better approach to this, or is there something in-built which could help?

Answer 1

Here's one approach, using TreeMap. It looks up your number of milliseconds in a pre-populated map, finds the appropriate entry and does the division.

Just create one of these objects, and call the format method as many times as you need to.

Note that it's not quite right for negative arguments to format - but you might want to put your own logic in around that, for example, to throw some kind of exception.

import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;

public class TimeFormatter {

    private NavigableMap<Long,String> timeUnits = new TreeMap<>();

    public TimeFormatter() {
        timeUnits.put(Long.MIN_VALUE, " is not a valid argument");
        timeUnits.put(1L, " milliseconds");
        timeUnits.put(1000L, " seconds");
        timeUnits.put(60 * 1000L, " minutes");
        timeUnits.put(60 * 60 * 1000L, " hours");
        timeUnits.put(24 * 60 * 60 * 1000L, " days");
        timeUnits.put(365 * 24 * 60 * 60 * 1000L, " years");
        timeUnits.put(1000000L * 365 * 24 * 60 * 60 * 1000L, " million years");
        timeUnits.put(1000000000L * 365 * 24 * 60 * 60 * 1000L, " billion years");
    }

    public String format(long milliseconds) {
        Map.Entry<Long,String> unitBelow = timeUnits.floorEntry(milliseconds);
        return milliseconds / unitBelow.getKey() + unitBelow.getValue();
    }
}

Answer 2

How many days in a year?

    if(decayTime > 365)
    {
        decayTime /= 365;
        readable = decayTime + " years";

This isn't quite correct. There are closer to 365.2425 days in a year. Don't forget leap years and leap centuries. And on the scale of millions and billions of years, you can expect leap seconds.

Make constants static

If you use a NavigableMap, you should make it static final, as it will have the same values for every instance of the class.

Consider

public class TimeFormatter {

    private static final NavigableMap<Long,String> TIME_UNITS = new TreeMap<>();

    static {
        TIME_UNITS.put(Long.MIN_VALUE, " is not a valid argument");
        TIME_UNITS.put(TimeUnit.SECONDS.toSeconds(1), " seconds");
        TIME_UNITS.put(TimeUnit.MINUTES.toSeconds(1), " minutes");
        TIME_UNITS.put(TimeUnit.HOURS.toSeconds(1), " hours");
        TIME_UNITS.put(TimeUnit.DAYS.toSeconds(1), " days");
        TIME_UNITS.put(TimeUnit.DAYS.toSeconds(1) * 3652425 / 10000, " years");
        TIME_UNITS.put(TimeUnit.DAYS.toSeconds(100L * 3652425), " million years");
        TIME_UNITS.put(TimeUnit.DAYS.toSeconds(100000L * 3652425), " billion years");
    }

I also put the name in ALL_CAPS, as that is a common Java convention for constants.

I used a static initializer block.

I did not try to include leap seconds.

It's not clear to me why days and years but not weeks, months, decades, centuries, and millennia. Fortnights are a reasonable exclusion, but the others are pretty standard.

Answer 3

Here is a quick edit to Daivd Wallace's answer to incorporate TimeUnit as @krp suggested.

import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.concurrent.TimeUnit;

public class TimeFormatter {

    private NavigableMap<Long,String> timeUnits = new TreeMap<>();

    public TimeFormatter() {
        timeUnits.put(Long.MIN_VALUE, " is not a valid argument");
        timeUnits.put(TimeUnit.SECONDS.toSeconds(1), " seconds");
        timeUnits.put(TimeUnit.MINUTES.toSeconds(1), " minutes");
        timeUnits.put(TimeUnit.HOURS.toSeconds(1), " hours");
        timeUnits.put(TimeUnit.DAYS.toSeconds(1), " days");
        timeUnits.put(TimeUnit.DAYS.toSeconds(365), " years");
        timeUnits.put(TimeUnit.DAYS.toSeconds(365 * 1000000L), " million years");
        timeUnits.put(TimeUnit.DAYS.toSeconds(365 * 1000000L * 1000), " billion years");
    }

    public String format(long milliseconds) {
        Map.Entry<Long,String> unitBelow = timeUnits.floorEntry(milliseconds);

        int time = (int) (milliseconds / unitBelow.getKey());
        String formatted = time + unitBelow.getValue();

        if(time == 1 && unitBelow.getKey() < TimeUnit.DAYS.toSeconds(365 * 1000000L)) formatted = formatted.substring(0, formatted.length()-1); //Remove plural

        return formatted;
    }
}

This version also handles plurals by removing the trailing 's'.

It's not perfect as TimeUnit only scales to days, but it removes a lot of the magic numbers.