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
  • Want to write a single page app with #ExtJS? View @zachagardner's video tutorial series to get you started: http://t.co/XFYDT6YNWA
    July 29, 2014 at 3:50 PM
  • A #JavaScript promise is an I.O.U. to return a value in the future. Learn about them: http://t.co/6wCz9b7e4v
    July 29, 2014 at 1:36 PM
  • A huge welcome to John Holland who joined the Keyhole team today!
    July 28, 2014 at 4:56 PM
  • We think #JavaScript Promises are cool. Here's a good introduction from @mauget - http://t.co/6wCz9b7e4v
    July 28, 2014 at 2:19 PM
  • There's a new post on the Keyhole blog by @mauget: #JavaScript Promises Are Cool - http://t.co/6wCz9b7e4v
    July 28, 2014 at 9:52 AM
  • Thank your #Sysadmin - today is System Administrator Appreciation Day. http://t.co/LcvDNa9kPg
    July 25, 2014 at 8:05 AM
  • @rickincanada Thx for your tweet! Shoot us an email at asktheteam@keyholesoftware.com so we can set up a time to talk. Have a good day.
    July 24, 2014 at 3:33 PM
  • Never used JAXB? Check out a simple usage pattern that pairs #JAXB’s data binding capabilities with JPA - http://t.co/Ki9G04HV5e
    July 24, 2014 at 9:53 AM
  • Guess what today is? Tell An Old Joke Day - http://t.co/835ORWMX6N! So, why do programmers always confuse Halloween & Xmas? 31 Oct = 25 Dec
    July 24, 2014 at 8:45 AM
  • MT @midwestio: Posted another #midwestio talk recording to our YouTube channel: @MinaMarkham on modular CSS. Watch: http://t.co/aU3LpfUoi4
    July 24, 2014 at 8:25 AM
  • We just posted pictures from our National Hot Dog Day Lunch Cookout. Check them out - http://t.co/To06plaw1C
    July 23, 2014 at 4:14 PM
  • Good free cheat sheet - #Java Performance Optimization Refcard from @DZone: http://t.co/7vBgsmqy08
    July 23, 2014 at 10:48 AM
  • Did you know today is a holiday? It's National Hot Dog Day! We're gearing up for our team lunch hot dog cookout & can't wait to celebrate.
    July 23, 2014 at 9:43 AM
  • Check out our newest blog: #JAXB – A Newcomer’s Perspective, Part 1 http://t.co/Ki9G04HV5e
    July 22, 2014 at 1:22 PM
  • New post on the Keyhole blog by Mark Adelsberger: #JAXB – A Newcomer’s Perspective, Part 1 http://t.co/Ki9G04HV5e
    July 21, 2014 at 2:27 PM
  • If you're a Java dev, you're likely familiar with Annotations. But have you created your own #Java Annotations? Ex - http://t.co/BgCsYjxZKF
    July 18, 2014 at 12:10 PM
  • RT @gamasutra: Don't Miss: Unconventional Tips for Improving your Programming Skills http://t.co/6TFox7CKHU
    July 16, 2014 at 3:20 PM
  • We're about to send out our free monthly tech newsletter. Dev tips/articles via email. Not on the list yet? Sign up - http://t.co/F8h0NSiicZ
    July 15, 2014 at 11:57 AM
  • Have you ever tried creating your own #Java annotations? See a situation where it was beneficial - http://t.co/BgCsYjxZKF
    July 15, 2014 at 8:36 AM
  • There's a new post on the Keyhole blog by @jhackett01: Creating Your Own #Java Annotations - http://t.co/BgCsYjxZKF
    July 14, 2014 at 1:43 PM
Keyhole Software
8900 State Line Road, Suite 455
Leawood, KS 66206
ph: 877-521-7769
© 2014 Keyhole Software, LLC. All rights reserved.