Convert EBCDIC to ASCII in Java

1. Introduction

IBM created EBCDIC (Extended Binary Coded Decimal Interchange Code) in the 1960s and is still used in IBM mainframe environments. Later, ASCII became the universal standard due to its ease and universality as the modern system standard.

Working with Java and EBCDIC data can be tricky because Java typically uses encodings like ASCII or UTF-8 by default. This incompatibility complicates integration with legacy systems. To make information portable and readable, we need to translate EBCDIC to ASCII.

In this tutorial, we’ll see how Java’s support for native encoding simplifies this conversion.

2. Understanding EBCDIC and ASCII

When we mention character encodings, two names come up frequently: ASCII and EBCDIC. They both do the same thing: they encode characters as bytes. But they’re quite different in structure and use. Learning about them makes us appreciate the importance of conversion in Java and how it allows legacy data to be accessed in newer systems.

Let’s implement a small Java program:

private static final Logger logger = LoggerFactory.getLogger(LogbackRollingExample.class)
public static void main(String[] args) {
        byte[] ebcdicBytes = new byte[] { (byte)0xC1, (byte)0xC2, (byte)0xC3 };

        String text = new String(ebcdicBytes, Charset.forName("Cp037"));
        logger.info(text);
    }

We have ebcdicBytes with raw bytes here and decode them using Charset.forName(“Cp037”), instructing Java to read the bytes as EBCDIC code page 037. Then, with System.out.println(text), we print out the decoded data as a readable string. This easy step just demonstrates the difference between raw EBCDIC bytes that aren’t comprehensible and readable ASCII text once decoded.

3. Step-by-Step Conversion Approach

To reliably make EBCDIC to ASCII conversions in Java, we can divide the process into easy steps. We need to determine the proper EBCDIC code page first. Then, we decode raw bytes into a Java String. We then re-encode the string back to ASCII or UTF-8 for use in new systems. This process ensures precise and transportable data conversion.

Let’s implement the step-by-step conversion approach:

private static final Logger logger = LoggerFactory.getLogger(LogbackRollingExample.class)
public static void main(String[] args) { 
        byte[] ebcdicData = { (byte)0xC8, (byte)0x85, (byte)0x93, (byte)0x93, (byte)0x96 }; 
        String unicodeText = new String(ebcdicData, Charset.forName("Cp037")); 
        byte[] asciiData = unicodeText.getBytes(StandardCharsets.US_ASCII); 
        logger.info(new String(asciiData, StandardCharsets.US_ASCII)); 
    }

Here, the ebcdicData raw bytes hold text in EBCDIC encoding. With Charset.forName(“Cp037”), we decode the bytes to a String that Java internally represents as Unicode. We then call getBytes(StandardCharsets.US_ASCII) to re-encode that string back to ASCII. Finally, System.out.println prints the result, showing how the pipeline of conversions makes legacy data readable on a modern system. This breakdown keeps it simple and avoids loss of data.

4. Practical Java Example

Now that we’ve seen the individual steps, let’s put them together in a complete example. This helps us understand how to read EBCDIC-encoded data from a file, convert it into ASCII, and then display it in a readable format. Java makes this process straightforward by combining FileInputStream, Charset, and StandardCharsets. Let’s implement the Java program to illustrate:

private static final Logger logger = LoggerFactory.getLogger(LogbackRollingExample.class)
public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("input.ebc");
        byte[] ebcdicData = fis.readAllBytes();
        fis.close();
        String unicodeText = new String(ebcdicData, Charset.forName("Cp037"));
        byte[] asciiData = unicodeText.getBytes(StandardCharsets.US_ASCII);
        logger.info(new String(asciiData, StandardCharsets.US_ASCII));
    }

Here, we begin reading all raw bytes from input.ebc through FileInputStream. By using Charset.forName(“Cp037”), we decode EBCDIC bytes to an internal Java String Unicode. Then we call getBytes(StandardCharsets.US_ASCII) to re-encode data back to ASCII. Finally, System.out.println prints out the transformed string, and it’s readable. This whole process illustrates how we can convert from a legacy file to modern text processing in just a few simple steps.

5. Alternative Approaches and Considerations

While the straightforward conversion with Charset is sufficient, for large files we can follow alternative approaches. 

As an example, we can use InputStreamReader and OutputStreamWriter to stream huge files, or CharsetDecoder and CharsetEncoder when fine-grained control over encoding is needed. They give us room for flexibility and serve performance or customization needs.

Now, let’s explore the alternative approaches:

private static final Logger logger = LoggerFactory.getLogger(LogbackRollingExample.class)
public static void main(String[] args) {
        try (
            InputStreamReader reader = new InputStreamReader(
                new FileInputStream("input.ebc"), 
                Charset.forName("Cp037")
            );
            OutputStreamWriter writer = new OutputStreamWriter(
                new FileOutputStream("output.txt"), 
                StandardCharsets.US_ASCII
            )
        ) {
            char[] buffer = new char[1024];
            int length;

            while ((length = reader.read(buffer)) != -1) {
                writer.write(buffer, 0, length);
            }

            logger.info("Conversion complete! See output.txt");

        } catch (IOException e) {
            logger.info("Error during conversion");
        }
    }

Here, we read input.ebc via InputStreamReader and specify Cp037 in order to correctly decode EBCDIC characters. Then we write output via OutputStreamWriter with StandardCharsets.US_ASCII, so the target output file is in ASCII. With a buffer, we stream-read from the EBCDIC source and stream-write to the ASCII target.

This streaming approach is efficient for large files and does not try to load everything into memory while correctly doing the encoding conversion.

6. Conclusion

In this article, we discussed how Java makes it simple to convert between EBCDIC and ASCII, natively supporting several code pages. The key step is selecting the correct variant of EBCDIC (say, Cp037 or Cp1047), byte-decoding into Unicode, and converting back into ASCII or UTF-8.

From quick String conversions to streaming with InputStreamReader and OutputStreamWriter, Java offers multiple techniques for getting legacy data readable and transportable on current systems.

As always, the full code is available over on Github.