如何在Java中将含ASCII码的文件转换为字符文件？

Hey there! Let's break down how to read ASCII codes from a file, convert them to their corresponding characters, and write those characters to a new file in Java. The approach depends a bit on how your ASCII codes are stored in the input file—so I'll cover the two most common scenarios below.

Scenario 1: One ASCII Code per Line #

If your input file has one integer (representing an ASCII code) on each line (e.g., 65, 97, 33), here's a straightforward implementation using Java's modern IO APIs with try-with-resources (to automatically close streams and avoid resource leaks):

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;

public class AsciiConverter {
    public static void main(String[] args) {
        String inputFilePath = "ascii_codes.txt";
        String outputFilePath = "converted_chars.txt";

        try {
            // Read all lines from the input file
            List<String> asciiLines = Files.readAllLines(Paths.get(inputFilePath));

            // Convert each ASCII code to its corresponding character
            String result = asciiLines.stream()
                    .map(line -> {
                        try {
                            int asciiValue = Integer.parseInt(line.trim());
                            // Validate the standard ASCII range (0-127)
                            if (asciiValue < 0 || asciiValue > 127) {
                                throw new IllegalArgumentException("Invalid ASCII value: " + asciiValue);
                            }
                            return String.valueOf((char) asciiValue);
                        } catch (NumberFormatException e) {
                            System.err.println("Skipping invalid line: " + line + " - " + e.getMessage());
                            return ""; // Skip non-integer entries
                        } catch (IllegalArgumentException e) {
                            System.err.println(e.getMessage());
                            return ""; // Skip out-of-range values
                        }
                    })
                    .collect(Collectors.joining());

            // Write the converted characters to the output file
            Files.write(Paths.get(outputFilePath), result.getBytes());
            System.out.println("Conversion completed successfully! Check " + outputFilePath);

        } catch (IOException e) {
            System.err.println("Error handling files: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Key Notes for This Scenario: #

• try-with-resources isn't explicitly needed here because Files.readAllLines and Files.write handle resource management internally, but the stream processing ensures clean handling.
• We trim each line to ignore any leading/trailing whitespace (like spaces or tabs) that might be in the input file.
• We validate that each value is within the standard ASCII range (0-127) and skip invalid entries with a clear error message.

Scenario 2: Continuous ASCII Code Digits #

If your input file has continuous digits representing ASCII codes (e.g., 656667979899 which translates to ABCabc), we need to split the string into valid ASCII values. Since ASCII codes range from 0-127, each value can be 1, 2, or 3 digits long. Here's how to handle this:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.charset.StandardCharsets;

public class ContinuousAsciiConverter {
    public static void main(String[] args) {
        String inputFilePath = "continuous_ascii.txt";
        String outputFilePath = "converted_continuous_chars.txt";

        try {
            // Read the entire input file as a single string, removing all whitespace
            String asciiString = Files.readString(Paths.get(inputFilePath), StandardCharsets.UTF_8)
                                      .replaceAll("\\s+", "");

            StringBuilder result = new StringBuilder();
            int i = 0;
            while (i < asciiString.length()) {
                // Try 3-digit values first (only valid if ≤127)
                if (i + 3 <= asciiString.length()) {
                    String threeDigit = asciiString.substring(i, i + 3);
                    int value = Integer.parseInt(threeDigit);
                    if (value <= 127) {
                        result.append((char) value);
                        i += 3;
                        continue;
                    }
                }
                // Fall back to 2-digit values
                if (i + 2 <= asciiString.length()) {
                    String twoDigit = asciiString.substring(i, i + 2);
                    int value = Integer.parseInt(twoDigit);
                    result.append((char) value);
                    i += 2;
                    continue;
                }
                // Finally, read 1-digit values
                String oneDigit = asciiString.substring(i, i + 1);
                int value = Integer.parseInt(oneDigit);
                result.append((char) value);
                i += 1;
            }

            // Write the result to the output file
            Files.write(Paths.get(outputFilePath), result.toString().getBytes(StandardCharsets.UTF_8));
            System.out.println("Conversion completed successfully! Check " + outputFilePath);

        } catch (IOException e) {
            System.err.println("Error handling files: " + e.getMessage());
            e.printStackTrace();
        } catch (NumberFormatException e) {
            System.err.println("Invalid digit sequence in input file: " + e.getMessage());
        }
    }
}

Key Notes for This Scenario: #

• We first remove all whitespace from the input string to handle any accidental spaces or newlines.
• The logic prioritizes 3-digit values only if they're within the ASCII range (≤127), then falls back to 2-digit, then 1-digit values. This ensures we correctly parse sequences like 12797 (which is 127 + 97 = a).

General Best Practices #

• Always handle file IO exceptions to avoid crashes and get meaningful error messages.
• Specify the character encoding when writing the output file (we used StandardCharsets.UTF_8 here) to ensure consistency across systems—though ASCII is a subset of UTF-8, so the default usually works too.
• For large files, avoid reading the entire file into memory at once. Instead, use a BufferedReader to read line-by-line (for scenario 1) or in chunks (for scenario 2) to reduce memory usage.

内容的提问来源于stack exchange，提问作者maxwellhertz