下面我将从最简单到最完整地介绍几种方法。

核心原理

Java 中的字符串字面量支持 Unicode 转义序列。String str = "\u4e2d\u6587"; 编译器在编译时就会将其解析为 中文 这两个汉字，我们的任务就是将输入的字符串（"\\u4e2d\\u6587"，注意这里有两个反斜杠，因为在字符串中 \ 是转义字符）中的 \uXXXX 部分找出来，并替换成对应的字符。

最简单直接的方法（适用于已知 Unicode 序列）

如果你的代码中直接写死了 Unicode 序列，这是最简单的方式。

public class SimpleUnicode {
    public static void main(String[] args) {
        // Java 编译器会自动将 \uXXXX 转换为对应的字符
        String str = "\u4e2d\u6587";
        System.out.println(str); // 输出: 中文
    }
}

注意：这种方法在编译时就完成了转换，而不是在运行时，所以它不适用于处理一个包含 \uXXXX 格式的字符串变量。

使用 StringEscapeUtils (推荐，最方便)

这是最常用、最推荐的方法，尤其适用于处理动态的、包含 \uXXXX 格式的字符串，它来自 Apache Commons Lang 库，专门用来处理字符串的转义和反转义。

步骤 1: 添加依赖

如果你使用 Maven，在 pom.xml 中添加：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version> <!-- 使用最新版本 -->
</dependency>

如果你使用 Gradle，在 build.gradle 中添加：

implementation 'org.apache.commons:commons-lang3:3.12.0' // 使用最新版本

步骤 2: 使用 StringEscapeUtils.unescapeJava()

这个方法可以将 Java 字符串中的所有转义序列（包括 \n, \t, \uXXXX 等）转换成它们的原始形式。

import org.apache.commons.lang3.StringEscapeUtils;
public class CommonsLangExample {
    public static void main(String[] args) {
        // 输入的字符串，包含了 \u 转义序列
        String unicodeString = "\\u4e2d\\u56fd\\u4eba\\u6b63\\u5728\\u5b66\\u4e60\\u7f16\\u7a0b";
        // 使用 StringEscapeUtils 进行反转义
        String chineseString = StringEscapeUtils.unescapeJava(unicodeString);
        System.out.println("原始 Unicode 字符串: " + unicodeString);
        System.out.println("转换后的中文字符串: " + chineseString);
        // 输出:
        // 原始 Unicode 字符串: \u4e2d\u56fd\u4eba\u6b63\u5728\u5b66\u4e60\u7f16\u7a0b
        // 转换后的中文字符串: 中国人正在学习编程
    }
}

优点：

• 非常方便,一行代码搞定。
• 功能全面,能处理所有 Java 转义字符。
• 代码可读性高。

手动实现（不依赖外部库）

如果你不想引入外部库,可以自己写一个简单的转换函数，核心思路是使用正则表达式匹配 \u 后面跟着4个十六进制字符的模式，然后进行替换。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ManualConversion {
    public static void main(String[] args) {
        String unicodeString = "\\u4e2d\\u56fd\\u4eba\\u6b63\\5728\\u5b66\\u4e60\\u7f16\\u7a0b";
        String chineseString = convertUnicodeToChinese(unicodeString);
        System.out.println("原始 Unicode 字符串: " + unicodeString);
        System.out.println("转换后的中文字符串: " + chineseString);
    }
    public static String convertUnicodeToChinese(String unicodeStr) {
        // 正则表达式，匹配 \u 开头，后面跟着4个十六进制字符的模式
        // Pattern.LITERAL 防止正则表达式中的 \ 被误解
        Pattern pattern = Pattern.compile("\\\\u([0-9a-fA-F]{4})", Pattern.LITERAL);
        Matcher matcher = pattern.matcher(unicodeStr);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            // 找到 Unicode 码点，"4e2d"
            String unicodeCode = matcher.group(1);
            // 将十六进制字符串转换为整数（字符码点）
            int charCode = Integer.parseInt(unicodeCode, 16);
            // 将码点转换为字符
            char ch = (char) charCode;
            // 用转换后的字符替换原始的 \uXXXX 字符串
            matcher.appendReplacement(sb, String.valueOf(ch));
        }
        // 处理完所有匹配后，将剩余部分添加到结果中
        matcher.appendTail(sb);
        return sb.toString();
    }
}

代码解析：

1. Pattern.compile("\\\\u([0-9a-fA-F]{4})", Pattern.LITERAL):
   • \\\\u: 在正则表达式中匹配一个字面上的 \u，因为 \ 是特殊字符，所以需要用 \\ 来表示一个 \。
   • ([0-9a-fA-F]{4}): 这是一个捕获组，匹配4个十六进制字符（0-9, a-f, A-F）。
   • Pattern.LITERAL: 让整个模式被当作字面量来处理，避免 \d 等被解释为元字符。
2. matcher.find(): 查找字符串中所有符合模式的子串。
3. matcher.group(1): 获取第一个捕获组的内容，也就是 Unicode 码点（如 "4e2d"）。
4. Integer.parseInt(unicodeCode, 16): 将十六进制字符串转换为十进制整数。
5. (char) charCode: 将整数强制转换为 char 类型，这个 char 就是中文字符。
6. matcher.appendReplacement(sb, ...) 和 matcher.appendTail(sb): 这是 Matcher 类的标准用法，用于高效地构建替换后的新字符串。

总结与对比

对于绝大多数 Java 方法二 (StringEscapeUtils.unescapeJava()) 是最佳选择，因为它既简单又可靠。