A Method For Creating A Human-Readable File Size

by on August 13, 2012 7:56 am

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

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.

	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 Updated Method

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.

	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;
    }
</code>

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, asktheteam@keyholesoftware.com

  • Share:

3 Responses to “A Method For Creating A Human-Readable File Size”

  1. David says:

    Has this patch been submitted to apache? I think they would find this useful…Here’s a link on how to submit? http://commons.apache.org/patches.html

Leave a Reply

Things Twitter is Talking About
  • Have a happy & safe holiday weekend!
    August 29, 2014 at 3:55 PM
  • Useful #JAXB primer that illustrates the power from tools & frameworks that unobtrusively interact with POJOs - http://t.co/J1s5DpcsCp
    August 29, 2014 at 3:19 PM
  • The Keyhole team fantasy football league begins! Huge thanks to our commissioner @zachagardner. Good luck to all in the virtual gridiron!
    August 28, 2014 at 5:30 PM
  • Shout out to last year's winner of our Keyhole #fantasyfootball league - Adi Rosenblum (@adidas28). Will his reign continue? :-)
    August 28, 2014 at 5:30 PM
  • @dashaun That is the perfect way to put it - we are very excited! Great to meet you officially.
    August 28, 2014 at 4:53 PM
  • Check out a quick intro to Functional Reactive Programing and #JavaScript - http://t.co/4LSt6aPJvG #FRP http://t.co/m6G1Kqbwyi
    August 28, 2014 at 4:06 PM
  • When you pair #JAXB & #JPA, you can expect some "gotchas." Here are techniques to help you overcome the hurdles - http://t.co/J1s5DpcsCp
    August 27, 2014 at 1:56 PM
  • Interesting perspective - Famo.us talks big, but jQuery Foundation isn't worried: http://t.co/o9lLpPoh2G Thoughts?
    August 27, 2014 at 12:41 PM
  • We are delighted to say that RJ (@RJvXP) & Donna (@dkbdevlab) join Keyhole today. Welcome to the team!
    August 27, 2014 at 9:22 AM
  • RT @codeproject: Learning MVC - Part 5 Repository Pattern in MVC3 Application with Entity Framework by Akhil Mittal http://t.co/z603gpAH…
    August 27, 2014 at 9:15 AM
  • Know a bright new grad looking to learn? We're seeking a team member on our business side of the Keyhole house - http://t.co/GDvFVmoMF9
    August 26, 2014 at 3:29 PM
  • When you pair #JAXB & #JPA, you can expect to encounter some "gotchas." Techniques & learning to overcome hurdles - http://t.co/J1s5DpcsCp
    August 26, 2014 at 11:12 AM
  • Don't miss Mark Adelsberger's newest post on the Keyhole blog: #JAXB – A Newcomer’s Perspective, Part 2 http://t.co/J1s5DpcsCp
    August 25, 2014 at 1:21 PM
  • A huge welcome to Mike Schlatter who joins the KHS team today!
    August 25, 2014 at 12:33 PM
  • Never used JAXB? Check out a simple usage pattern that pairs #JAXB’s data binding capabilities with JPA - http://t.co/Ki9G04pLR6
    August 22, 2014 at 8:35 AM
  • Check out a quick intro to Functional Reactive Programing and #JavaScript - http://t.co/YGSsz5eynl #FRP http://t.co/m6G1Kqbwyi
    August 21, 2014 at 11:32 AM
  • Our team is riding #BikeMS to support the fight against Multiple Sclerosis. Get involved - http://t.co/GGObSd073P http://t.co/vZpWRXkQ3z
    August 21, 2014 at 9:09 AM
  • @dtkachev Thanks for the tweet! The server is back up now - sorry for the inconvenience. Have a good day!
    August 21, 2014 at 9:03 AM
  • RT @m_evans10: @joewalnes A SQL query goes into a bar, walks up to two tables and asks, "Can I join you?"
    August 20, 2014 at 3:55 PM
  • Have you read @wdpitt's newest book? - Web Essentials using #JavaScript & #HTML5. Free PDF download via @InfoQ: http://t.co/lesuPJ770I
    August 20, 2014 at 2:31 PM
Keyhole Software
8900 State Line Road, Suite 455
Leawood, KS 66206
ph: 877-521-7769
© 2014 Keyhole Software, LLC. All rights reserved.