Compress and Uncompress Byte Array Using Deflater/Inflater

1. Overview

Data compression is a crucial aspect of software development that enables efficient storage and transmission of information. In Java, the Deflater and Inflater classes from the java.util.zip package provide a straightforward way to compress and decompress byte arrays.

In this short tutorial, we’ll explore how to use these classes with a simple example.

2. Compressing

The Deflater class uses the ZLIB compression library to compress data. Let’s see it in action:

public static byte[] compress(byte[] input) {
    Deflater deflater = new Deflater();
    deflater.setInput(input);
    deflater.finish();
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    byte[] buffer = new byte[1024];
    while (!deflater.finished()) {
        int compressedSize = deflater.deflate(buffer);
        outputStream.write(buffer, 0, compressedSize);
    }
    return outputStream.toByteArray();
}

In the above code, we’ve used several methods of the Deflater class to compress the input data:

• setInput(): set input data for compression
• finish(): indicate that compression should end with the current contents of the input
• deflate(): compress the data and fill to a specified buffer, then return the actual number of bytes of compressed data
• finished(): check if the end of the compressed data output stream has been reached

Additionally, we can use the setLevel() method to get better compression results. We can pass values from 0 to 9, corresponding to the range from no compression to best compression:

Deflater deflater = new Deflater();
deflater.setInput(input);
deflater.setLevel(5);

3. Uncompressing

Next, let’s decompress a byte array with the Inflater class:

public static byte[] decompress(byte[] input) throws DataFormatException {
    Inflater inflater = new Inflater();
    inflater.setInput(input);
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    byte[] buffer = new byte[1024];
    while (!inflater.finished()) {
        int decompressedSize = inflater.inflate(buffer);
        outputStream.write(buffer, 0, decompressedSize);
    }
    return outputStream.toByteArray();
}

This time, we used three methods of the Inflater class:

• setInput(): set input data for decompression
• finished(): check if the end of the compressed data stream has been reached
• inflate(): decompress bytes into the specified buffer and return the actual number of bytes uncompressed

4. Example

Let’s try out our methods with this simple example:

String inputString = "Baeldung helps developers explore the Java ecosystem and simply be better engineers. "
  + "We publish to-the-point guides and courses, with a strong focus on building web applications, Spring, "
  + "Spring Security, and RESTful APIs";
byte[] input = inputString.getBytes();
byte[] compressedData = compress(input);
byte[] decompressedData = decompress(compressedData);
System.out.println("Original: " + input.length + " bytes");
System.out.println("Compressed: " + compressedData.length + " bytes");
System.out.println("Decompressed: " + decompressedData.length + " bytes");
assertEquals(input.length, decompressedData.length);

The result will look like this:

Original: 220 bytes
Compressed: 168 bytes
Decompressed: 220 bytes

5. Conclusion

In this article, we’ve learned how to compress and uncompress a Java byte array using the Deflater and Inflater classes, respectively.

The example code from this article can be found over on GitHub.