Java Base64 encoding and decoding

In Java, Base64 encoding and decoding are commonly used for encoding binary data as text.

This is especially useful in contexts where data needs to be safely transmitted over networks, stored in text files, or embedded in XML or JSON.

Java provides built-in support for Base64 encoding and decoding through the java.util.Base64 class introduced in Java 8.

Base64 Encoding and Decoding Basics

The Base64 class provides three built-in encoders and decoders:

• Basic: Standard Base64 encoding without any line separators.
• URL and Filename Safe: Base64 encoding modified to be URL and filename safe by replacing certain characters.
• MIME: Base64 encoding suitable for MIME (Multipurpose Internet Mail Extensions) with line breaks.

1. Basic Base64 Encoding and Decoding

The Base64.getEncoder() and Base64.getDecoder() methods provide basic encoding and decoding.

Example: Encoding and Decoding a Simple String

import java.util.Base64;

public class Base64BasicExample {
    public static void main(String[] args) {
        String originalString = "Hello, World!";
        
        // Encode
        String encodedString = Base64.getEncoder().encodeToString(originalString.getBytes());
        System.out.println("Encoded String: " + encodedString);
        
        // Decode
        byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded String: " + decodedString);
    }
}

Explanation

• Encoding: Base64.getEncoder().encodeToString(originalString.getBytes()) encodes the originalString to Base64.
• Decoding: Base64.getDecoder().decode(encodedString) decodes the Base64 string back to bytes, which are then converted to a string.

Output

Encoded String: SGVsbG8sIFdvcmxkIQ==
Decoded String: Hello, World!

2. Encoding and Decoding with URL and Filename Safe Base64

The URL-safe encoder replaces the + and / characters with – and _, making the encoded string safe for URLs and filenames.

Example: URL-Safe Encoding and Decoding

import java.util.Base64;

public class Base64UrlExample {
    public static void main(String[] args) {
        String originalString = "Hello, URL-safe World!";
        
        // Encode using URL-safe Base64 encoder
        String encodedUrlString = Base64.getUrlEncoder().encodeToString(originalString.getBytes());
        System.out.println("URL-Safe Encoded String: " + encodedUrlString);
        
        // Decode
        byte[] decodedBytes = Base64.getUrlDecoder().decode(encodedUrlString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded String: " + decodedString);
    }
}

Explanation

• URL Encoding: Base64.getUrlEncoder().encodeToString() encodes the string using a URL-safe Base64 variant.
• URL Decoding: Base64.getUrlDecoder().decode() decodes the URL-safe Base64 string back to the original text.

Output

URL-Safe Encoded String: SGVsbG8sIFVSTC1zYWZlIFdvcmxkIQ==
Decoded String: Hello, URL-safe World!

3. MIME Base64 Encoding with Line Breaks

The MIME encoder inserts line breaks every 76 characters, which is suitable for encoding large data like files or images in MIME format for emails.

Example: MIME Encoding and Decoding

import java.util.Base64;

public class Base64MimeExample {
    public static void main(String[] args) {
        String originalString = "This is a long string that might need to be split into multiple lines for MIME encoding purposes.";

        // Encode with MIME Base64 encoder
        String encodedMimeString = Base64.getMimeEncoder().encodeToString(originalString.getBytes());
        System.out.println("MIME Encoded String: " + encodedMimeString);
        
        // Decode
        byte[] decodedBytes = Base64.getMimeDecoder().decode(encodedMimeString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded String: " + decodedString);
    }
}

Explanation

• MIME Encoding: Base64.getMimeEncoder().encodeToString() encodes the string and adds line breaks every 76 characters.
• MIME Decoding: Base64.getMimeDecoder().decode() decodes the MIME Base64-encoded string back to the original text.

Output

MIME Encoded String: VGhpcyBpcyBhIGxvbmcgc3RyaW5nIHRoYXQgbWlnaHQgbmVlZCB0byBiZSBzcGxpdCBp
bnRvIG11bHRpcGxlIGxpbmVzIGZvciBNSU1FIGVuY29kaW5nIHB1cnBvc2VzLg==
Decoded String: This is a long string that might need to be split into multiple lines for MIME encoding purposes.

4. Encoding and Decoding Binary Data (e.g., Image Files)

Base64 encoding is often used to encode binary data for transmission or storage. This example demonstrates encoding an image file into a Base64 string and decoding it back to the original format.

Example: Encoding and Decoding an Image File

import java.util.Base64;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;

public class Base64BinaryExample {
    public static void main(String[] args) {
        try {
            // Load the image file as bytes
            byte[] fileContent = Files.readAllBytes(Paths.get("example.png"));

            // Encode the bytes into a Base64 string
            String encodedString = Base64.getEncoder().encodeToString(fileContent);
            System.out.println("Encoded Image String: " + encodedString);

            // Decode the Base64 string back to bytes
            byte[] decodedBytes = Base64.getDecoder().decode(encodedString);

            // Write the decoded bytes to a new file
            Files.write(Paths.get("decoded_example.png"), decodedBytes);
            System.out.println("Image successfully decoded and saved as 'decoded_example.png'");
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Explanation

• Encoding: Files.readAllBytes(Paths.get(“example.png”)) reads the binary content of an image file. We then encode it using Base64.getEncoder().encodeToString().
• Decoding: Base64.getDecoder().decode(encodedString) converts the Base64 string back into bytes, which are saved as a new image file.

5. Customizing MIME Encoding with Line Length and Line Separator

The Base64.getMimeEncoder() allows you to specify a custom line length and line separator. This can be useful when working with protocols or systems that require specific formatting.

Example: Custom MIME Encoding with Line Length and Separator

import java.util.Base64;

public class Base64CustomMimeExample {
    public static void main(String[] args) {
        String originalString = "This is a custom MIME encoding example that requires specific line lengths and separators.";

        // Customize line length to 50 characters and use "#" as the line separator
        Base64.Encoder mimeEncoder = Base64.getMimeEncoder(50, "#".getBytes());

        // Encode the string
        String encodedString = mimeEncoder.encodeToString(originalString.getBytes());
        System.out.println("Custom MIME Encoded String:\n" + encodedString);
    }
}

Explanation

• Custom MIME Encoding: Base64.getMimeEncoder(50, “#”.getBytes()) encodes the string with a custom line length of 50 characters and uses # as the line separator.
• The output is formatted with line breaks and custom separators.

6. Encoding and Decoding Objects Using Serialization

Base64 can be used to encode objects by serializing them into a byte array, then encoding the byte array to a Base64 string.

Example: Serializing and Encoding an Object to Base64

import java.util.Base64;
import java.io.*;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class Base64ObjectExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        
        try {
            // Serialize and encode the object to Base64
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(person);
            objectOutputStream.close();

            String encodedObject = Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray());
            System.out.println("Encoded Object: " + encodedObject);

            // Decode and deserialize the object from Base64
            byte[] decodedBytes = Base64.getDecoder().decode(encodedObject);
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decodedBytes);
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            Person decodedPerson

 = (Person) objectInputStream.readObject();
            objectInputStream.close();

            System.out.println("Decoded Object: " + decodedPerson);
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Explanation

• Serialization: We serialize the Person object to a byte array and then encode it to a Base64 string.
• Deserialization: We decode the Base64 string back to bytes and then deserialize it to a Person object.

Summary

Java’s Base64 class provides a robust way to handle Base64 encoding and decoding.

Key points include:

• Basic Encoding: Used for general-purpose encoding, with no line breaks.
• URL and Filename Safe Encoding: Uses URL-safe characters, making the output suitable for URLs and filenames.
• MIME Encoding: Adds line breaks, making it suitable for large data and MIME-based applications.
• Binary Data: Useful for encoding binary files like images or documents.
• Object Serialization: Enables encoding of objects by serializing them to a byte array.

By mastering these methods, you can securely and efficiently handle data transmission and storage requirements in Java applications.