Java/Kotlin实现二进制文件与十六进制文本互转并确保还原有效性

Java 实现 #

二进制文件转十六进制文本 #

读取二进制文件字节，将每个字节转为两位大写十六进制字符串，用空格分隔后写入文本文件，确保字节无符号处理避免解析错误。

import java.io.*;
import java.nio.charset.StandardCharsets;

public class HexConverter {
    // 二进制转十六进制文本
    public static void binToHexFile(String inputBinPath, String outputHexPath) throws IOException {
        try (InputStream in = new FileInputStream(inputBinPath);
             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputHexPath), StandardCharsets.US_ASCII))) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            boolean first = true;
            while ((bytesRead = in.read(buffer)) != -1) {
                for (int i = 0; i < bytesRead; i++) {
                    if (!first) {
                        writer.write(' ');
                    }
                    // 处理有符号byte，转为无符号整数后格式化
                    writer.write(String.format("%02X", buffer[i] & 0xFF));
                    first = false;
                }
            }
        }
    }

    // 十六进制文本还原为二进制文件
    public static void hexToBinFile(String inputHexPath, String outputBinPath) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputHexPath), StandardCharsets.US_ASCII));
             OutputStream out = new FileOutputStream(outputBinPath)) {
            String line;
            while ((line = reader.readLine()) != null) {
                // 按任意空白分割，过滤空字符串
                String[] hexStrings = line.trim().split("\\s+");
                for (String hex : hexStrings) {
                    if (hex.isEmpty()) continue;
                    // 十六进制转byte，兼容大小写
                    byte b = (byte) Integer.parseInt(hex, 16);
                    out.write(b);
                }
            }
        }
    }

    // 测试示例
    public static void main(String[] args) {
        try {
            binToHexFile("test.zip", "test.hex");
            hexToBinFile("test.hex", "test_restored.zip");
            System.out.println("转换完成，还原文件可正常解压");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Kotlin 实现 #

利用Kotlin标准库扩展函数简化代码，逻辑与Java一致，更简洁直观。

import java.io.File
import java.nio.charset.StandardCharsets

// 二进制文件转十六进制文本
fun binToHexFile(inputBinPath: String, outputHexPath: String) {
    File(inputBinPath).inputStream().use { inputStream ->
        File(outputHexPath).bufferedWriter(StandardCharsets.US_ASCII).use { writer ->
            val buffer = ByteArray(4096)
            var bytesRead: Int
            var first = true
            while (inputStream.read(buffer).also { bytesRead = it } != -1) {
                for (i in 0 until bytesRead) {
                    if (!first) writer.write(' ')
                    writer.write("%02X".format(buffer[i].toUByte()))
                    first = false
                }
            }
        }
    }
}

// 十六进制文本还原为二进制文件
fun hexToBinFile(inputHexPath: String, outputBinPath: String) {
    File(inputHexPath).bufferedReader(StandardCharsets.US_ASCII).use { reader ->
        File(outputBinPath).outputStream().use { outputStream ->
            reader.lineSequence()
                .flatMap { line -> line.trim().split(Regex("\\s+")).filter { it.isNotEmpty() } }
                .forEach { hex ->
                    val byte = hex.toInt(16).toByte()
                    outputStream.write(byte.toInt())
                }
        }
    }
}

// 测试示例
fun main() {
    try {
        binToHexFile("test.exe", "test.hex")
        hexToBinFile("test.hex", "test_restored.exe")
        println("转换完成，还原文件可正常运行")
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

关键注意事项 #

• 字节无符号处理：Java中byte为有符号类型，转十六进制需用& 0xFF转为无符号整数；Kotlin可直接用toUByte()避免负数解析错误。
• 字符集兼容性：必须使用ASCII/UTF-8存储十六进制文本，防止乱码导致还原失败。
• 空白字符兼容：还原时需过滤换行、制表符等空白，仅解析有效十六进制对。
• 大文件优化：用4KB缓冲区读写，避免一次性加载文件到内存，提升性能并支持大文件转换。

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