Click here to Skip to main content
Click here to Skip to main content

A Method for Creating a Human-Readable File Size

By , 23 Aug 2012
Rate this:
Please Sign up or sign in to vote.

Recently, I was working on a project in which the users needed to see a list of files available for download. While it wasn’t a specific requirement, I thought it might be helpful to have the file size appear next to the file name. This is a common enough use case that I figured that there must be an open source library that would give a human-readable file size if I were to give it a file length.

A quick search later, I found the Apache Commons FileUtils class and the byteCountToDisplaySize method. Looking at the JavaDoc, we see that it returns a “human-readable version of the file size, where the input represents a specific number of bytes. If the size is over 1GB, the size is returned as the number of whole GB, i.e. the size is rounded down to the nearest GB boundary. Similarly for the 1MB and 1KB boundaries.”

This seemed to be what I was looking for, and for this particular use case it works fine. However, it could be misleading if you needed more accurate sizes. If I’m looking at a file that has a size of 1.99 MB, it would display as 1 MB. Even worse, a 1.99 GB file would display as only being 1 GB in size. This is even pointed out in a JIRA ticket attached to the JavaDoc.

I decided to implement an improved version. Surprisingly, I got my inspiration from Windows Explorer. When you look at the drive size and space free in Windows Explorer (in this case, the Windows 7 version), you’ll only see the three most significant digits of the number. Here I’ll implement a version of the method, based on the original byteCountToDisplaySize, to have the same behavior.

A Look at the Original

The original class divides the byte length by multiples of a byte from high (yottabyte) to low (kilobyte). When one of those divisions equals a number above zero (since it is an integer division), it has reached the appropriate multiple and outputs the value followed by the appropriate symbol.

For this method, I’ll follow the same pattern to determine the appropriate symbol:

/**
 * The number of bytes in a kilobyte.
 */
public static final BigInteger ONE_KB = BigInteger.valueOf(1024);

/**
 * The number of bytes in a megabyte.
 */
public static final BigInteger ONE_MB = ONE_KB.multiply(ONE_KB);

/**
 * The number of bytes in a gigabyte.
 */
public static final BigInteger ONE_GB = ONE_KB.multiply(ONE_MB);

/**
 * The number of bytes in a terabyte.
 */
public static final BigInteger ONE_TB = ONE_KB.multiply(ONE_GB);

/**
 * The number of bytes in a petabyte.
 */
public static final BigInteger ONE_PB = ONE_KB.multiply(ONE_TB);

/**
 * The number of bytes in an exabyte.
 */
public static final BigInteger ONE_EB = ONE_KB.multiply(ONE_PB);

/**
 * The number of bytes in a zettabyte.
 */
public static final BigInteger ONE_ZB = ONE_KB.multiply(ONE_EB);

/**
 * The number of bytes in a yottabyte.
 */
public static final BigInteger ONE_YB = ONE_KB.multiply(ONE_ZB);

/**
 * Returns a human-readable version of the file size, where the input
 * represents a specific number of bytes.
 *
 * @param size
 *         the number of bytes
 * @return a human-readable display value (includes units - YB, ZB, EB, PB, TB, GB,
 *      MB, KB or bytes)
 */
public static String byteCountToDisplaySize(BigInteger size) {
   String displaySize;
   if (size.divide(ONE_YB).compareTo(BigInteger.ZERO) > 0) {
      displaySize = String.valueOf(size.divide(ONE_YB)) + " YB";
   } else if (size.divide(ONE_ZB).compareTo(BigInteger.ZERO) > 0) {
      displaySize = String.valueOf(size.divide(ONE_ZB)) + " ZB";
   } else if (size.divide(ONE_EB).compareTo(BigInteger.ZERO) > 0) {
      displaySize = String.valueOf(size.divide(ONE_EB)) + " EB";
   } else if (size.divide(ONE_PB).compareTo(BigInteger.ZERO) > 0) {
      displaySize = String.valueOf(size.divide(ONE_PB)) + " PB";
   } else if (size.divide(ONE_TB).compareTo(BigInteger.ZERO) > 0) {
      displaySize = String.valueOf(size.divide(ONE_TB)) + " TB";
   } else if (size.divide(ONE_GB).compareTo(BigInteger.ZERO) > 0) {
      displaySize = String.valueOf(size.divide(ONE_GB)) + " GB";
   } else if (size.divide(ONE_MB).compareTo(BigInteger.ZERO) > 0) {
      displaySize = String.valueOf(size.divide(ONE_MB)) + " MB";
   } else if (size.divide(ONE_KB).compareTo(BigInteger.ZERO) > 0) {
      displaySize = String.valueOf(size.divide(ONE_KB)) + " KB";
   } else {
      displaySize = String.valueOf(size) + " bytes";
   }
   return displaySize;
}

That code replicates the behavior of the original byteCountToDisplaySize method. The if/else if /else block structure will remain the same for our method, but the calculation of the displaySize must change. A new method, getThreeSigFigs, will be created for this.

Our New Calculation

private static String getThreeSigFigs(double displaySize) {
 String number = String.valueOf(displaySize);
 StringBuffer trimmedNumber = new StringBuffer();
 int cnt = 0;
 for (char digit : number.toCharArray()) {
    if (cnt < 3) {
       trimmedNumber.append(digit);
    }
    if (digit != '.') {
       cnt++;
    }
 }
 return trimmedNumber.toString();
}

The above method will grab the first three digits and the decimal, if it occurs before the third digit, and output it as a string. Now let’s plug this into the method:

The Updated Method

public static String byteCountToDisplaySize(BigInteger size) {
String displaySize;
BigDecimal decimalSize = new BigDecimal(size);

if (size.divide(ONE_YB).compareTo(BigInteger.ZERO) > 0) {
   displaySize = String.valueOf(size.divide(ONE_YB)) + " YB";
} else if (size.divide(ONE_ZB).compareTo(BigInteger.ZERO) > 0) {
   displaySize = getThreeSigFigs(decimalSize.divide(new BigDecimal(ONE_ZB))) + " ZB";
} else if (size.divide(ONE_EB).compareTo(BigInteger.ZERO) > 0) {
   displaySize = getThreeSigFigs(decimalSize.divide(new BigDecimal(ONE_EB))) + " EB";
} else if (size.divide(ONE_PB).compareTo(BigInteger.ZERO) > 0) {
   displaySize = getThreeSigFigs(decimalSize.divide(new BigDecimal(ONE_PB))) + " PB";
} else if (size.divide(ONE_TB).compareTo(BigInteger.ZERO) > 0) {
   displaySize = getThreeSigFigs(decimalSize.divide(new BigDecimal(ONE_TB))) + " TB";
} else if (size.divide(ONE_GB).compareTo(BigInteger.ZERO) > 0) {
   displaySize = getThreeSigFigs(decimalSize.divide(new BigDecimal(ONE_GB))) + " GB";
} else if (size.divide(ONE_MB).compareTo(BigInteger.ZERO) > 0) {
   displaySize = getThreeSigFigs(decimalSize.divide(new BigDecimal(ONE_MB))) + " MB";
} else if (size.divide(ONE_KB).compareTo(BigInteger.ZERO) > 0) {
   displaySize = getThreeSigFigs(decimalSize.divide(new BigDecimal(ONE_KB))) + " KB";
} else {
   displaySize = String.valueOf(size) + " bytes";
}
   return displaySize;
}

We leave the method out for two of the branches. The first branch in the extremely rare case that we have a file over 999 YB and the last branch because we will always show all of the digits for values under one kilobyte. But how do we know this code works?

Unit Test

package com.keyholesoftware;

import java.util.Arrays;
import java.util.Collection;

import junit.framework.Assert;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class KHSFileUtilsTest {

    private Long input;
    private String output;

    public KHSFileUtilsTest(Long input, String output) {
       this.input = input;
       this.output = output;
    }

    @Parameters
    public static Collection<Object[]> generateData() {
       return Arrays.asList(new Object[][] { { 0L, "0 bytes" },
          { 27L, "27 bytes" }, { 999L, "999 bytes" }, {1000L, "1000 bytes" },
          {1023L, "1023 bytes"},{1024L, "1.0 KB"},{1728L, "1.68 KB"},{110592L, "108 KB"},
          {7077888L, "6.75 MB"}, {452984832L, "432 MB"}, {28991029248L, "27.0 GB"},
          {1855425871872L, "1.68 TB"}, {9223372036854775807L, "8.0 EB"}});
    }

    @Test
    public void testByteCountToDisplaySizeBigInteger() {
       Assert.assertEquals(output, KHSFileUtils.byteCountToDisplaySize(input));
    }
}

I use a parameterized JUnit test here so we can easily test multiple inputs against their expected output.

I hope you’ll find this improved version of the method byteCountToDisplaySize (with surprising inspiration from Windows Explorer) useful. Please let me know if you have any questions.

– Brice McIver,

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

Keyhole Software
Keyhole Software
United States United States
Keyhole is a software development and consulting firm with a tight-knit technical team. We work primarily with Java, .NET, and Mobile technologies, specializing in application development. We love the challenge that comes in consulting and blog often regarding some of the technical situations and technologies we face. Kansas City, St. Louis and Chicago.
Group type: Organisation (No members)


Follow on   Twitter   Google+

Comments and Discussions

 
Suggestionuseful but code issues Pinmemberkilikil23-Aug-12 22:41 
GeneralMy vote of 5 PinmemberChristian Amado23-Aug-12 5:52 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web01 | 2.8.140415.2 | Last Updated 23 Aug 2012
Article Copyright 2012 by Keyhole Software
Everything else Copyright © CodeProject, 1999-2014
Terms of Use
Layout: fixed | fluid