Java 实例 – 字符串反转（千字长文）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在编程世界中，字符串操作始终是一个核心话题。无论是开发基础工具还是复杂系统，字符串的反转功能都像一面“代码之镜”，帮助开发者实现文本的逆序处理。今天，我们将深入探讨“Java 实例 – 字符串反转”这一主题。通过循序渐进的方式，从基础语法到优化技巧，带读者一步步掌握这一实用技能。

字符串反转的应用场景远超想象。例如：

• 回文检测：判断一个字符串是否像“level”或“上海自来水来自海上”一样正反一致。
• 密码处理：在某些加密算法中，字符串需要经过逆序操作增强安全性。
• 日志分析：将时间戳或路径字符串逆序排列，便于快速定位关键信息。

想象一下，如果镜子突然消失，人们将无法调整自己的仪容。字符串反转就像这面“代码之镜”，帮助开发者从不同角度观察和处理数据。

Java 提供了现成的工具类 StringBuilder，其 reverse() 方法能轻松实现字符串反转。这种方法简单高效，适合快速开发场景。

public class SimpleReversal {  
    public static String reverseWithStringBuilder(String input) {  
        return new StringBuilder(input).reverse().toString();  
    }  

    public static void main(String[] args) {  
        String original = "Hello World!";  
        String reversed = reverseWithStringBuilder(original);  
        System.out.println("反转后：" + reversed); // 输出 "!dlroW olleH"  
    }  
}  

原理比喻：
StringBuilder 类似于一个“文字拼图板”，它允许我们像移动磁贴一样重新排列字符。调用 reverse() 方法后，拼图板会自动将所有字符翻转，最终生成新的字符串。

若想避免使用现成工具类，可以手动遍历字符串的字符数组。这种方法更贴近底层逻辑，适合理解字符串反转的实现原理。

public class ManualReversal {  
    public static String reverseManually(String input) {  
        char[] chars = input.toCharArray();  
        int left = 0;  
        int right = chars.length - 1;  
        while (left < right) {  
            // 交换左右指针的字符  
            char temp = chars[left];  
            chars[left] = chars[right];  
            chars[right] = temp;  
            left++;  
            right--;  
        }  
        return new String(chars);  
    }  

    public static void main(String[] args) {  
        String original = "Java";  
        String reversed = reverseManually(original);  
        System.out.println("反转后：" + reversed); // 输出 "avaJ"  
    }  
}  

原理比喻：
这如同在一条直线上同时安排两位“搬运工”——左指针从起点出发，右指针从终点出发，两人不断交换手中物品（字符），直到相遇为止。

递归是一种“分而治之”的策略，适合追求代码简洁性的开发者。但需注意递归深度过大会导致栈溢出风险。

public class RecursiveReversal {  
    public static String reverseRecursively(String input) {  
        if (input.length() <= 1) {  
            return input;  
        }  
        // 递归处理子字符串，将首字符移动到末尾  
        return reverseRecursively(input.substring(1)) + input.charAt(0);  
    }  

    public static void main(String[] args) {  
        String original = "递归反转";  
        String reversed = reverseRecursively(original);  
        System.out.println("反转后：" + reversed); // 输出 "準反归递"  
    }  
}  

原理比喻：
递归就像剥洋葱，每次只处理最外层的“一层”（即字符串的首字符），然后将剩余部分继续递归处理，直到剥到最内层（字符串长度为1时）。

以下表格对比三种方法的优缺点：

（表格与上文之间空一行）

关键观察：

• 三种方法时间复杂度均为线性，但 StringBuilder 的常数项最小，因为它直接调用底层优化过的 C++ 实现。
• 递归方法的空间复杂度因栈帧累积可能更高，处理超长字符串时需谨慎。

问题1：反转空字符串或 null 时抛出异常

在方法中添加空值检查：

if (input == null || input.isEmpty()) {  
    return input; // 或抛出异常，根据业务需求选择  
}  

问题2：反转 Unicode 字符串时出现乱码

Java 的 char 类型使用 16 位存储，对于 Unicode 中的 32 位字符（如部分表情符号），需改用 codePoint 处理：

public static String reverseUnicodeAware(String input) {  
    int length = input.codePointCount(0, input.length());  
    StringBuilder sb = new StringBuilder(length);  
    for (int i = input.length() - 1; i >= 0; ) {  
        int codePoint = input.codePointAt(i);  
        sb.appendCodePoint(codePoint);  
        i -= Character.charCount(codePoint);  
    }  
    return sb.reverse().toString(); // 双反转实现逆序  
}  

有时需要反转字符串的特定部分而非整体。例如，反转“Hello World”中的“World”：

public static String reverseSegment(String input, int start, int end) {  
    char[] chars = input.toCharArray();  
    while (start < end) {  
        char temp = chars[start];  
        chars[start++] = chars[end];  
        chars[end--] = temp;  
    }  
    return new String(chars);  
}  

// 调用示例：  
String original = "Hello World";  
String result = reverseSegment(original, 6, 10); // 反转索引6到10的字符  
System.out.println(result); // 输出 "Hello dlroW"  

通过本文的实践，读者已掌握了三种字符串反转方法，并理解了其底层原理和优化方向。无论是使用现成工具类的高效方案，还是手动实现的控制细节，或是递归带来的代码优雅性，都展现了 Java 实例中“字符串反转”的多面性。

建议读者尝试将这些方法应用到真实项目中，例如：

1. 验证用户输入的密码是否满足“逆序复杂度”要求；
2. 在日志系统中逆序输出错误堆栈信息；
3. 实现字符串的“镜像加密”功能。

编程就像建造乐高城堡，掌握每一个基础积木（如字符串反转）的拼接技巧，将帮助开发者构建更复杂的系统。希望本文能成为你技术成长路上的一块坚实砖石。

（全文约 1700 字）