Java实现UTF-8转Unicode的代码详解

// File: src/main/java/com/example/Utf8ToUnicodeConverter.java
package com.example;
 
import java.io.*;
import java.nio.*;
import java.nio.channels.FileChannel;
import java.nio.charset.*;
import java.nio.file.*;
import java.util.concurrent.*;
import java.util.function.Consumer;
 
/**
 * Utf8ToUnicodeConverter
 * 提供将 UTF-8 编码的文本转换为 Unicode 转义字符串的静态方法。
 */
public class Utf8ToUnicodeConverter {
 
    // 默认缓冲区大小 (8KB)
    private static final int DEFAULT_BUFFER_SIZE = 8192;
    // 默认线程数 (可根据 CPU 核心数调整)
    private static final int DEFAULT_THREAD_COUNT = Runtime.getRuntime().availableProcessors();
 
    /**
     * 单一字符串转换，返回转换结果
     * @param input 原始 UTF-8 文本
     * @return 转换后的 Unicode 转义文本
     */
    public static String convert(String input) {
        if (input == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder(input.length() * 2);
        for (int i = 0; i < input.length(); i++) {
            int codePoint = input.codePointAt(i);
            if (Character.isSupplementaryCodePoint(codePoint)) {
                // 对 Supplementary Plane 拆分代理对
                char[] surrogates = Character.toChars(codePoint);
                for (char ch : surrogates) {
                    sb.append(toUnicodeEscaped(ch));
                }
                i++; // 跳过低位代理
            } else {
                char ch = input.charAt(i);
                if (ch >= 0x20 && ch <= 0x7E) {
                    sb.append(ch);
                } else {
                    sb.append(toUnicodeEscaped(ch));
                }
            }
        }
        return sb.toString();
    }
 
    /**
     * 流式转换 API
     * @param reader 任意字符读取器
     * @param writer 任意字符写出器
     * @param preserveAscii 是否保留 ASCII 可打印字符
     * @throws IOException IO 异常
     */
    public static void convert(Reader reader, Writer writer, boolean preserveAscii) throws IOException {
        BufferedReader br = new BufferedReader(reader);
        BufferedWriter bw = new BufferedWriter(writer);
        int ch;
        while ((ch = br.read()) != -1) {
            char c = (char) ch;
            if (preserveAscii && c >= 0x20 && c <= 0x7E) {
                bw.write(c);
            } else {
                bw.write(toUnicodeEscaped(c));
            }
        }
        bw.flush();
    }
 
    /**
     * 文件转换，支持多线程
     * @param in 输入文件路径
     * @param out 输出文件路径
     * @param bufferSize 缓冲区大小
     * @param threadCount 线程数量
     * @param preserveAscii 是否保留 ASCII 可打印字符
     * @throws Exception 抛出异常
     */
    public static void convert(Path in, Path out, int bufferSize, int threadCount, boolean preserveAscii) throws Exception {
        long fileSize = Files.size(in);
        long chunkSize = fileSize / threadCount;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        ConcurrentMap<Integer, String> results = new ConcurrentHashMap<>();
        // 分片处理
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            final long start = index * chunkSize;
            final long end = (index == threadCount - 1) ? fileSize : (start + chunkSize);
            executor.submit(() -> {
                try (FileChannel fc = FileChannel.open(in, StandardOpenOption.READ)) {
                    ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
                    fc.position(start);
                    StringBuilder partSb = new StringBuilder((int) (end - start) * 2);
                    while (fc.position() < end) {
                        buffer.clear();
                        fc.read(buffer);
                        buffer.flip();
                        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
                        CharBuffer cb = decoder.decode(buffer);
                        for (int i1 = 0; i1 < cb.length(); i1++) {
                            char c = cb.get(i1);
                            if (preserveAscii && c >= 0x20 && c <= 0x7E) {
                                partSb.append(c);
                            } else {
                                partSb.append(toUnicodeEscaped(c));
                            }
                        }
                    }
                    results.put(index, partSb.toString());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        }
        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        // 按顺序写入
        try (BufferedWriter bw = Files.newBufferedWriter(out, StandardCharsets.UTF_8)) {
            for (int i = 0; i < threadCount; i++) {
                bw.write(results.get(i));
            }
        }
    }
 
    /**
     * 异步回调转换
     * @param input 原始文本
     * @param callback 转换完成后的回调
     */
    public static void convertAsync(String input, Consumer<String> callback) {
        CompletableFuture.supplyAsync(() -> convert(input))
                .thenAccept(callback);
    }
 
    /**
     * 将单个字符转为 Unicode 转义形式
     * @param ch 字符
     * @return 对应的 \\uXXXX 格式字符串
     */
    private static String toUnicodeEscaped(char ch) {
        return String.format("\\u%04X", (int) ch);
    }
}
 
// File: src/test/java/com/example/Utf8ToUnicodeConverterTest.java
package com.example;
 
import org.junit.jupiter.api.*;
import java.nio.file.*;
import static org.junit.jupiter.api.Assertions.*;
 
/**
 * Utf8ToUnicodeConverterTest
 * 单元测试，覆盖 ASCII、中文、Supplementary Plane、空串等场景
 */
public class Utf8ToUnicodeConverterTest {
 
    @Test
    public void testAscii() {
        String input = "Hello, World!";
        String expected = "Hello, World!";
        assertEquals(expected, Utf8ToUnicodeConverter.convert(input));
    }
    
    @Test
    public void testChinese() {
        String input = "中文测试";
        String expected = "\\u4E2D\\u6587\\u6D4B\\u8BD5";
        assertEquals(expected, Utf8ToUnicodeConverter.convert(input));
    }
 
    @Test
    public void testSupplementaryPlane() {
        String input = "😊"; // U+1F60A
        String result = Utf8ToUnicodeConverter.convert(input);
        assertTrue(result.contains("\\uD83D") && result.contains("\\uDE0A"));
    }
 
    @Test
    public void testEmpty() {
        assertNull(Utf8ToUnicodeConverter.convert((String) null));
        assertEquals("", Utf8ToUnicodeConverter.convert(""));
    }
}