## 1. Overview

When we get the size of a file in Java, usually, we’ll get the value in bytes. However, once a file is large enough, for example, 123456789 bytes, seeing the length expressed in bytes becomes a challenge for us trying to comprehend how big the file is.

In this tutorial, we’ll explore how to convert file size in bytes into a human-readable format in Java.

## 2. Introduction to the Problem

As we’ve talked about earlier, when the size of a file in bytes is large, it’s not easy to understand for humans. Therefore, when we present an amount of data to humans, we often use a proper SI prefix, such as KB, MB, GB, and so on, to make a large number human-readable. For example, “270GB” is much easier to understand than “282341192 Bytes”.

However, when we get a file size through the standard Java API, usually, it’s in bytes. So, to have the human-readable format, we need to dynamically convert the value from the byte unit to the corresponding binary prefix, for example, converting “282341192 bytes” to “207MiB”, or converting “2048 bytes” to “2KiB”.

It’s worth mentioning that there are two variants of the unit prefixes:

- Binary Prefixes – They are the powers of 1024; for example, 1MiB = 1024 KiB, 1GiB = 1024 MiB, and so on
- SI (International System of Units) Prefixes – They are the powers of 1000; for example, 1MB = 1000 KB, 1GB = 1000 MB, and so on.

**Our tutorial will focus on both binary prefixes and SI prefixes.**

## 3. Solving the Problem

We may have already realized that **the key to solving the problem is finding the suitable unit dynamically.**

For example, if the input is less than 1024, say 200, then we need to take the byte unit to have “200 Bytes”. However, when the input is greater than 1024 but less than 1024 * 1024, for instance, 4096, we should use the KiB unit, so we have “4 KiB”.

But, let’s solve the problem step by step. Before we dive into the unit determination logic, let’s first define all required units and their boundaries.

### 3.1. Defining Required Units

As we’ve known,** one unit multiplied by 1024 will transit to the unit at the next level**. Therefore, we can create constants indicating all required units with their base values:

```
private static long BYTE = 1L;
private static long KiB = BYTE << 10;
private static long MiB = KiB << 10;
private static long GiB = MiB << 10;
private static long TiB = GiB << 10;
private static long PiB = TiB << 10;
private static long EiB = PiB << 10;
```

As the code above shows, we’ve used the binary left shift operator (<<) to calculate the base values. Here, **“***x << 10*” does the same as “*x * 1024*” since 1024 is two to the power of 10.

For SI Prefixes **one unit multiplied by 1000 will transit to the unit at the next level**. Therefore, we can create constants indicating all required units with their base values:

```
private static long KB = BYTE * 1000;
private static long MB = KB * 1000;
private static long GB = MB * 1000;
private static long TB = GB * 1000;
private static long PB = TB * 1000;
private static long EB = PB * 1000;
```

Assuming that we’ve determined the right unit and we want to express the file size to two decimal places, we can create a method to output the result:

```
private static DecimalFormat DEC_FORMAT = new DecimalFormat("#.##");
private static String formatSize(long size, long divider, String unitName) {
return DEC_FORMAT.format((double) size / divider) + " " + unitName;
}
```

Next, let’s understand quickly what the method does. As we’ve seen in the code above, first, we defined the number format *DEC_FORMAT.*

The *divider* parameter is the base value of the chosen unit, while the *String* argument *unitName* is the unit’s name. For example, if we’ve chosen KiB as the suitable unit, *divider=1024* and *unitName = “KiB”.*

**This method centralizes the division calculation and the number format conversion.**

Now, it’s time to move to the core part of the solution: finding out the right unit.

### 3.2. Determining the Unit

Let’s first have a look at the implementation of the unit determination method:

```
public static String toHumanReadableBinaryPrefixes(long size) {
if (size < 0)
throw new IllegalArgumentException("Invalid file size: " + size);
if (size >= EiB) return formatSize(size, EiB, "EiB");
if (size >= PiB) return formatSize(size, PiB, "PiB");
if (size >= TiB) return formatSize(size, TiB, "TiB");
if (size >= GiB) return formatSize(size, GiB, "GiB");
if (size >= MiB) return formatSize(size, MiB, "MiB");
if (size >= KiB) return formatSize(size, KiB, "KiB");
return formatSize(size, BYTE, "Bytes");
}
```

```
public static String toHumanReadableSIPrefixes(long size) {
if (size < 0)
throw new IllegalArgumentException("Invalid file size: " + size);
if (size >= EB) return formatSize(size, EB, "EB");
if (size >= PB) return formatSize(size, PB, "PB");
if (size >= TB) return formatSize(size, TB, "TB");
if (size >= GB) return formatSize(size, GB, "GB");
if (size >= MB) return formatSize(size, MB, "MB");
if (size >= KB) return formatSize(size, KB, "KB");
return formatSize(size, BYTE, "Bytes");
}
```

Now, let’s walk through the method and understand how it works.

First, we want to make sure the input is a positive number.

**Then, we check the units in the direction from high (EB) to low (Byte). **Once we find the input *size* is greater than or equal to the current unit’s base value, the current unit will be the right one.

As soon as we find the right unit, we can call the previously created *formatSize* method to get the final result as a *String*.

### 3.3. Testing the Solution

Now, let’s write a unit test method to verify if our solution works as expected. To simplify testing the method, let’s initialize a *Map**<Long, String> *holding inputs and the corresponding expected results:

```
private static Map<Long, String> DATA_MAP_BINARY_PREFIXES = new HashMap<Long, String>() {{
put(0L, "0 Bytes");
put(1023L, "1023 Bytes");
put(1024L, "1 KiB");
put(12_345L, "12.06 KiB");
put(10_123_456L, "9.65 MiB");
put(10_123_456_798L, "9.43 GiB");
put(1_777_777_777_777_777_777L, "1.54 EiB");
}};
```

```
private final static Map<Long, String> DATA_MAP_SI_PREFIXES = new HashMap<Long, String>() {{
put(0L, "0 Bytes");
put(999L, "999 Bytes");
put(1000L, "1 KB");
put(12_345L, "12.35 KB");
put(10_123_456L, "10.12 MB");
put(10_123_456_798L, "10.12 GB");
put(1_777_777_777_777_777_777L, "1.78 EB");
}};
```

Next, let’s go through the *Map** DATA_MAP*, taking each key value as the input and verifying if we can obtain the expected result:

`DATA_MAP.forEach((in, expected) -> Assert.assertEquals(expected, FileSizeFormatUtil.toHumanReadable(in)));`

When we execute the unit test, it passes.

## 4. Improving the Solution With an Enum and Loop

So far, we’ve solved the problem. The solution is pretty straightforward. In the *toHumanReadable* method, we’ve written multiple *if* statements to determine the unit.

If we think about the solution carefully, a couple of points might be error-prone:

- The order of those
*if* statements must be fixed as they are in the method.
- In each
*if* statement, we’ve hard-coded the unit constant and the corresponding name as a *String* object.

Next, let’s see how to improve the solution.

### 4.1. Creating the *SizeUnit enum*

Actually, we can convert the unit constants into an *enum* so that we don’t have to hard-code the names in the method:

```
enum SizeUnitBinaryPrefixes {
Bytes(1L),
KiB(Bytes.unitBase << 10),
MiB(KiB.unitBase << 10),
GiB(MiB.unitBase << 10),
TiB(GiB.unitBase << 10),
PiB(TiB.unitBase << 10),
EiB(PiB.unitBase << 10);
private final Long unitBase;
public static List<SizeUnitBinaryPrefixes> unitsInDescending() {
List<SizeUnitBinaryPrefixes> list = Arrays.asList(values());
Collections.reverse(list);
return list;
}
//getter and constructor are omitted
}
```

```
enum SizeUnitSIPrefixes {
Bytes(1L),
KB(Bytes.unitBase * 1000),
MB(KB.unitBase * 1000),
GB(MB.unitBase * 1000),
TB(GB.unitBase * 1000),
PB(TB.unitBase * 1000),
EB(PB.unitBase * 1000);
private final Long unitBase;
public static List<SizeUnitSIPrefixes> unitsInDescending() {
List<SizeUnitSIPrefixes> list = Arrays.asList(values());
Collections.reverse(list);
return list;
}
//getter and constructor are omitted
}
```

As the *enum SizeUnit* above shows, a *SizeUnit* instance holds both *unitBase* and *name*.

Further, since we want to check the units in “descending” order later, we’ve created a helper method, *unitsInDescending,* to return all units in the required order.

**With this ***enum*, we don’t have to code the names manually.

Next, let’s see if we can make some improvement on the set of *if* statements.

### 4.2. Using a Loop to Determine the Unit

As our *SizeUnit enum *can provide all units in a *List* in descending order, we can replace the set of *if* statements with a *for* loop:

```
public static String toHumanReadableWithEnum(long size) {
List<SizeUnit> units = SizeUnit.unitsInDescending();
if (size < 0) {
throw new IllegalArgumentException("Invalid file size: " + size);
}
String result = null;
for (SizeUnit unit : units) {
if (size >= unit.getUnitBase()) {
result = formatSize(size, unit.getUnitBase(), unit.name());
break;
}
}
return result == null ? formatSize(size, SizeUnit.Bytes.getUnitBase(), SizeUnit.Bytes.name()) : result;
}
```

As the code above shows, the method follows the same logic as the first solution. In addition, **it avoids those unit constants, multiple ***if* statements, and hard-coded unit names.

To make sure it works as expected, let’s test our solution:

`DATA_MAP.forEach((in, expected) -> Assert.assertEquals(expected, FileSizeFormatUtil.toHumanReadableWithEnum(in)));`

The test passes when we execute it.

## 5. Using the *Long.numberOfLeadingZeros* Method

We’ve solved the problem by checking units one by one and taking the first one that satisfies our condition.

Alternatively, we can use the *Long.numberOfLeadingZeros* method from the Java standard API to determine which unit the given size value falls in.

Next, let’s take a closer look at this interesting approach.

### 5.1. Introduction to the *Long.numberOfLeadingZeros* Method

**The ***Long.numberOfLeadingZeros* method returns the number of zero bits preceding the leftmost one-bit in the binary representation of the given *Long* value.

As **Java’s ***Long* type is a 64-bit integer, *Long.numberOfLeadingZeros(0L) = 64*. A couple of examples may help us understand the method quickly:

```
1L = 00... (63 zeros in total) .. 0001 -> Long.numberOfLeadingZeros(1L) = 63
1024L = 00... (53 zeros in total) .. 0100 0000 0000 -> Long.numberOfLeadingZeros(1024L) = 53
```

Now, we’ve understood the *Long.numberOfLeadingZeros* method. But why can it help us to determine the unit?

Let’s figure it out.

### 5.2. The Idea to Solve the Problem

We’ve known the factor between the units is 1024, which is two to the power of ten (*2^10*). Therefore, **if we calculate the number of leading zeros of each unit’s base value, the difference between two adjacent units is always 10**:

```
Index Unit numberOfLeadingZeros(unit.baseValue)
----------------------------------------------------
0 Byte 63
1 KiB 53
2 MiB 43
3 GiB 33
4 TiB 23
5 PiB 13
6 EiB 3
```

Further, **we can calculate the number of leading zeros of the input value and see the result falls in which unit’s range to find the suitable unit**.

Next, let’s see an example – how to determine the unit and calculate the unit base value for the size 4096:

```
if 4096 < 1024 (Byte's base value) -> Byte
else:
numberOfLeadingZeros(4096) = 51
unitIdx = (numberOfLeadingZeros(1) - 51) / 10 = (63 - 51) / 10 = 1
unitIdx = 1 -> KB (Found the unit)
unitBase = 1 << (unitIdx * 10) = 1 << 10 = 1024
```

Next, let’s implement this logic as a method.

### 5.3. Implementing the Idea

Let’s create a method to implement the idea we’ve discussed just now:

```
public static String toHumanReadableByNumOfLeadingZeros(long size) {
if (size < 0) {
throw new IllegalArgumentException("Invalid file size: " + size);
}
if (size < 1024) return size + " Bytes";
int unitIdx = (63 - Long.numberOfLeadingZeros(size)) / 10;
return formatSize(size, 1L << (unitIdx * 10), " KMGTPE".charAt(unitIdx) + "iB");
}
```

As we can see, the method above is pretty compact. It doesn’t need unit constants or an *enum*. Instead, **we’ve created a ***String* containing units: *” KMGTPE”*. Then, we use the calculated *unitIdx* to pick the right unit letter and append the “iB” to build the complete unit name.

It’s worth mentioning that we leave the first character empty on purpose in the *String* *” KMGTPE”*. This is because the unit “*Byte*” doesn’t follow the pattern “**B*“, and we handled it separately: *if (size < 1024) return size + ” Bytes”; *

Again, let’s write a test method to make sure it works as expected:

`DATA_MAP.forEach((in, expected) -> Assert.assertEquals(expected, FileSizeFormatUtil.toHumanReadableByNumOfLeadingZeros(in)));`

## 6. Using Apache Commons IO

So far, we’ve implemented two different approaches to converting a file size value into a human-readable format.

Actually, some external library has already provided a method to solve the problem: Apache Commons-IO.

Apache Commons-IO’s *FileUtils* allows us to convert byte size to a human-readable format through the *byteCountToDisplaySize* method.

However, **this method rounds the decimal part up automatically**.

Finally, let’s test the *byteCountToDisplaySize* method with our input data and see what it prints:

`DATA_MAP.forEach((in, expected) -> System.out.println(in + " bytes -> " + FileUtils.byteCountToDisplaySize(in)));`

The test outputs:

```
0 bytes -> 0 bytes
1024 bytes -> 1 KB
1777777777777777777 bytes -> 1 EB
12345 bytes -> 12 KB
10123456 bytes -> 9 MB
10123456798 bytes -> 9 GB
1023 bytes -> 1023 bytes
```

## 7. Conclusion

In this article, we’ve addressed different ways to convert file size in bytes into a human-readable format.

As always, the code presented in this article is available over on GitHub.