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
  • Check out a quick intro to Functional Reactive Programing and #JavaScript - http://t.co/4LSt6aPJvG
    September 20, 2014 at 11:15 AM
  • In Part 2 of our series on creating your own #Java annotations, learn about processing them with the Reflection API - http://t.co/E1lr3RmjI7
    September 19, 2014 at 12:15 PM
  • The life of a Keyhole consultant - A Delicate Balance: It’s What We Do http://t.co/ToRpWY3aix Blog as true today as the day it was written.
    September 19, 2014 at 9:50 AM
  • 7 Things You Can Do to Become a Better Developer - http://t.co/llPNMUN8nQ
    September 19, 2014 at 8:43 AM
  • .@jessitron Good luck, you'll do great! Our team really enjoyed your KCDC14 talks.
    September 18, 2014 at 10:19 AM
  • RT @woodwardjd: 7 deadly sins of programming. I think I did all of this last week. #strangeloop http://t.co/f7QFq1SpqW
    September 18, 2014 at 10:03 AM
  • In Part 2 of our series on creating your own #Java annotations, learn about processing them with the Reflection API - http://t.co/E1lr3RmjI7
    September 17, 2014 at 3:18 PM
  • We send out our free monthly tech newsletter tomorrow - dev tips/articles via email. Not on the list? Sign up: http://t.co/h8kpjn419s
    September 16, 2014 at 2:58 PM
  • Want to chuckle? If programming languages were vehicles -http://t.co/quqHsUFCtR #funny
    September 16, 2014 at 11:41 AM
  • In Part 2 of our series on creating your own annotations, learn about processing #Java annotations using Reflection: http://t.co/DJZvQuarkc
    September 16, 2014 at 9:06 AM
  • Don't miss @jhackett01's newest post on the Keyhole blog - Processing #Java Annotations Using Reflection: http://t.co/E1lr3RmjI7
    September 15, 2014 at 12:02 PM
  • We're pretty excited - Keyhole's #BikeMS team raised 158% of their fundraising goal to benefit @MidAmericaMS. Plus, they had a great ride!
    September 15, 2014 at 10:38 AM
  • A huge welcome to David Kelly (@rheomatic) who officially joins the Keyhole team today! :-)
    September 15, 2014 at 10:00 AM
  • Sending warm thoughts to @eastlack, @cdesalvo, @wdpitt & all participating in #BikeMS this AM. Thanks for helping in the fight against MS!
    September 13, 2014 at 8:10 AM
  • .@rheomatic We are so excited to have you joining the team! Welcome :-)
    September 12, 2014 at 4:11 PM
  • As the official holiday is a Saturday, we're celebrating today! Happy (early) #ProgrammersDay to you! http://t.co/1CvUfrzytE
    September 12, 2014 at 1:55 PM
  • Tomorrow @cdesalvo, @eastlack, & @wdpitt are riding #BikeMS to benefit @MidAmericaMS. You can get involved, too - http://t.co/9boQwEUxth
    September 12, 2014 at 11:00 AM
  • RT @AgileDevs: 5 tips for great code reviews http://t.co/9PdbtEv0z8
    September 11, 2014 at 2:53 PM
  • The BEMs of Structuring #CSS - http://t.co/159suYtfx6 A quick introduction to the Block Element Modifier methodology.
    September 10, 2014 at 2:49 PM
  • A huge welcome to Joseph Post (@jsphpst) who has joined the Keyhole team this week!
    September 10, 2014 at 9:52 AM
Keyhole Software
8900 State Line Road, Suite 455
Leawood, KS 66206
ph: 877-521-7769
© 2014 Keyhole Software, LLC. All rights reserved.