Java字符串处理与算法实战指南

1. Java字符串算法核心攻略：从入门到精通

字符串处理是编程中最基础也是最重要的技能之一，在Java开发中尤其如此。无论是日常业务开发还是算法面试，字符串相关的题目都占据了相当大的比重。本文将从底层原理到高级算法，系统性地讲解Java字符串处理的核心技巧和解题思路。

提示：在ASCII码中，大小写英文字母和数字的十进制数值范围如下：

• 大写字母(A-Z)：65到90
• 小写字母(a-z)：97到122
• 数字(0-9)：48到57

2. Java字符串基础操作全解析

2.1 字符串基础操作

字符串在Java中是不可变对象，这意味着每次修改字符串都会创建一个新的对象。理解这一点对于编写高效的字符串处理代码至关重要。

java复制String s = "hello";

// 获取字符串长度
int len = s.length();  // 5

// 获取指定位置字符
char c = s.charAt(0);  // 'h'

// 截取子串(左闭右开)
String sub = s.substring(1, 4);  // "ell"

// 查找字符首次出现位置
int index = s.indexOf('l');  // 2

// 判断是否包含子串
boolean contains = s.contains("ell");  // true

// 字符串内容比较
boolean equals = s.equals("hello");  // true (不要用==比较字符串内容)

2.2 字符串与数组转换

字符串和字符数组之间的转换是字符串处理中的常见操作：

java复制// String → char[]
char[] chars = s.toCharArray();

// char[] → String
String s2 = new String(chars);

// String分割为String[]
String[] arr = "a,b,c".split(",");  // ["a", "b", "c"]

// String[]拼接为String
String s3 = String.join(",", arr);  // "a,b,c"

2.3 StringBuilder高效字符串拼接

在循环中拼接字符串时，务必使用StringBuilder而不是直接使用+操作符：

java复制// 错误示例：每次循环都会创建新对象
String s = "";
for (int i = 0; i < 10000; i++) {
    s += "a";  // O(n²)时间复杂度
}

// 正确示例：使用StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append("a");  // O(n)时间复杂度
}
String result = sb.toString();

2.4 字符判断与转换

Java提供了Character类来处理字符的各种判断和转换：

java复制char c = 'a';

// 判断字符类型
boolean isDigit = Character.isDigit(c);  // 是否数字
boolean isLetter = Character.isLetter(c);  // 是否字母
boolean isLetterOrDigit = Character.isLetterOrDigit(c);  // 是否字母或数字
boolean isLowerCase = Character.isLowerCase(c);  // 是否小写

// 字符转换
char lower = Character.toLowerCase('A');  // 'a'
char upper = Character.toUpperCase('a');  // 'A'

// 字符转数字
int num = '5' - '0';  // 5

3. 字符串算法五大核心题型

3.1 哈希表类问题

哈希表是解决字符串统计类问题的利器，特别是需要统计字符出现频率的场景。

3.1.1 字符频次统计模板

java复制// 方法1：使用HashMap统计（通用）
public Map<Character, Integer> countChars(String s) {
    Map<Character, Integer> map = new HashMap<>();
    for (char c : s.toCharArray()) {
        map.put(c, map.getOrDefault(c, 0) + 1);
    }
    return map;
}

// 方法2：使用数组统计（仅限ASCII字符，更快）
public int[] countCharsArray(String s) {
    int[] count = new int[128];  // 覆盖所有ASCII字符
    for (char c : s.toCharArray()) {
        count[c]++;
    }
    return count;
}

3.1.2 有效的字母异位词(LeetCode 242)

java复制public boolean isAnagram(String s, String t) {
    if (s.length() != t.length()) return false;
    
    int[] count = new int[26];
    for (char c : s.toCharArray()) {
        count[c - 'a']++;
    }
    
    for (char c : t.toCharArray()) {
        count[c - 'a']--;
        if (count[c - 'a'] < 0) {
            return false;
        }
    }
    
    return true;
}

3.1.3 字符串中的第一个唯一字符(LeetCode 387)

java复制public int firstUniqChar(String s) {
    int[] count = new int[26];
    
    // 第一次遍历统计频次
    for (char c : s.toCharArray()) {
        count[c - 'a']++;
    }
    
    // 第二次遍历查找第一个唯一字符
    for (int i = 0; i < s.length(); i++) {
        if (count[s.charAt(i) - 'a'] == 1) {
            return i;
        }
    }
    
    return -1;
}

3.2 双指针类问题

双指针技术常用于处理字符串反转、回文等问题。

3.2.1 反转字符串(LeetCode 344)

java复制public void reverseString(char[] s) {
    int left = 0, right = s.length - 1;
    while (left < right) {
        char temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
}

3.2.2 验证回文串(LeetCode 125)

java复制public boolean isPalindrome(String s) {
    int left = 0, right = s.length() - 1;
    
    while (left < right) {
        // 跳过非字母数字字符
        while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
            left++;
        }
        while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
            right--;
        }
        
        // 比较字符（忽略大小写）
        if (Character.toLowerCase(s.charAt(left)) != 
            Character.toLowerCase(s.charAt(right))) {
            return false;
        }
        
        left++;
        right--;
    }
    
    return true;
}

3.3 滑动窗口类问题

滑动窗口是解决子串问题的强大技术，可以将时间复杂度从O(n²)优化到O(n)。

3.3.1 无重复字符的最长子串(LeetCode 3)

java复制public int lengthOfLongestSubstring(String s) {
    if (s == null || s.length() == 0) return 0;
    
    int left = 0, maxLen = 0;
    Map<Character, Integer> map = new HashMap<>();
    
    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        
        // 如果字符已存在且在窗口内，移动左指针
        if (map.containsKey(c) && map.get(c) >= left) {
            left = map.get(c) + 1;
        }
        
        map.put(c, right);
        maxLen = Math.max(maxLen, right - left + 1);
    }
    
    return maxLen;
}

3.3.2 找到字符串中所有字母异位词(LeetCode 438)

java复制public List<Integer> findAnagrams(String s, String p) {
    List<Integer> result = new ArrayList<>();
    if (s.length() < p.length()) return result;
    
    int[] pCount = new int[26];
    int[] sCount = new int[26];
    
    // 统计p的字符频次
    for (char c : p.toCharArray()) {
        pCount[c - 'a']++;
    }
    
    // 初始化第一个窗口
    for (int i = 0; i < p.length(); i++) {
        sCount[s.charAt(i) - 'a']++;
    }
    if (Arrays.equals(pCount, sCount)) {
        result.add(0);
    }
    
    // 滑动窗口
    for (int i = p.length(); i < s.length(); i++) {
        // 加入新字符
        sCount[s.charAt(i) - 'a']++;
        // 移除旧字符
        sCount[s.charAt(i - p.length()) - 'a']--;
        
        if (Arrays.equals(pCount, sCount)) {
            result.add(i - p.length() + 1);
        }
    }
    
    return result;
}

3.4 动态规划类问题

动态规划常用于解决最长公共子串、最长回文子串等问题。

3.4.1 最长回文子串(LeetCode 5)

java复制public String longestPalindrome(String s) {
    if (s == null || s.length() < 2) return s;
    
    int start = 0, maxLen = 1;
    
    for (int i = 0; i < s.length(); i++) {
        // 奇数长度回文
        int len1 = expandAroundCenter(s, i, i);
        // 偶数长度回文
        int len2 = expandAroundCenter(s, i, i + 1);
        
        int len = Math.max(len1, len2);
        if (len > maxLen) {
            maxLen = len;
            start = i - (len - 1) / 2;
        }
    }
    
    return s.substring(start, start + maxLen);
}

private int expandAroundCenter(String s, int left, int right) {
    while (left >= 0 && right < s.length() && 
           s.charAt(left) == s.charAt(right)) {
        left--;
        right++;
    }
    return right - left - 1;
}

3.5 栈类问题

栈结构非常适合处理括号匹配、路径简化等具有"最近匹配"特性的问题。

3.5.1 有效的括号(LeetCode 20)

java复制public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '[' || c == '{') {
            stack.push(c);
        } else {
            if (stack.isEmpty()) return false;
            
            char top = stack.pop();
            if ((c == ')' && top != '(') || 
                (c == ']' && top != '[') || 
                (c == '}' && top != '{')) {
                return false;
            }
        }
    }
    
    return stack.isEmpty();
}

3.5.2 简化路径(LeetCode 71)

java复制public String simplifyPath(String path) {
    Stack<String> stack = new Stack<>();
    String[] parts = path.split("/");
    
    for (String part : parts) {
        if (part.equals("..")) {
            if (!stack.isEmpty()) {
                stack.pop();
            }
        } else if (!part.equals(".") && !part.isEmpty()) {
            stack.push(part);
        }
    }
    
    if (stack.isEmpty()) return "/";
    
    StringBuilder sb = new StringBuilder();
    for (String dir : stack) {
        sb.append("/").append(dir);
    }
    
    return sb.toString();
}

4. 字符串算法实战技巧

4.1 解题思维框架

1. 识别问题类型：根据题目特征判断属于哪类问题

   • 字符统计 → 哈希表
   • 子串问题 → 滑动窗口
   • 回文/反转 → 双指针
   • 括号匹配 → 栈
   • 最优解 → 动态规划

2. 从暴力解法开始：先思考最直接的解法，再考虑优化

3. 选择合适的数据结构：根据问题特点选择最高效的数据结构

4.2 常见陷阱与注意事项

1. 字符串不可变性：避免在循环中直接拼接字符串，使用StringBuilder

2. 字符串比较：使用equals()而不是==比较字符串内容

3. 边界条件处理：空字符串、单字符字符串等特殊情况

4. 索引越界：注意字符串索引范围是[0, length-1]

5. 字符编码：处理非ASCII字符时考虑Unicode编码

4.3 性能优化技巧

1. 数组替代HashMap：当字符集有限时(如仅小写字母)，使用数组比HashMap更高效

2. 提前终止：在满足条件时提前终止循环，减少不必要的计算

3. 空间优化：有些问题可以原地修改输入，减少额外空间使用

4. 预处理：对字符串进行预处理(如排序)可以简化后续处理

5. 字符串算法刷题路线

5.1 入门必刷(10题)

1. 344 反转字符串
2. 242 有效的字母异位词
3. 387 字符串中的第一个唯一字符
4. 125 验证回文串
5. 28 实现strStr()
6. 14 最长公共前缀
7. 58 最后一个单词的长度
8. 20 有效的括号
9. 392 判断子序列
10. 383 赎金信

5.2 进阶挑战(15题)

11. 3 无重复字符的最长子串
12. 5 最长回文子串
13. 49 字母异位词分组
14. 151 反转字符串中的单词
15. 438 找到字符串中所有字母异位词
16. 567 字符串的排列
17. 647 回文子串
18. 205 同构字符串
19. 290 单词规律
20. 459 重复的子字符串
21. 680 验证回文字符串 II
22. 696 计数二进制子串
23. 709 转换成小写字母
24. 771 宝石与石头
25. 819 最常见的单词

6. 字符串处理核心方法速查

java复制// 字符串访问
charAt(index)          // 获取指定位置字符
toCharArray()          // 转换为字符数组
substring(start, end)  // 截取子串(左闭右开)

// 字符串查找
indexOf(str)           // 查找子串位置
lastIndexOf(str)       // 从后向前查找
contains(str)          // 是否包含子串

// 字符串判断
isEmpty()              // 是否空字符串
equals(str)            // 内容比较
startsWith(prefix)     // 是否以指定前缀开始
endsWith(suffix)       // 是否以指定后缀结束

// 字符串修改
toLowerCase()          // 转换为小写
toUpperCase()          // 转换为大写
trim()                 // 去除首尾空白
replace(old, new)      // 替换子串

// 字符串分割与拼接
split(regex)           // 按正则分割
String.join(delimiter, elements) // 用分隔符拼接
StringBuilder.append() // 高效拼接

掌握这些字符串处理技巧和算法，你将能够高效解决绝大多数字符串相关问题。记住，理解算法背后的思想比死记硬背代码更重要。在实际应用中，根据具体问题灵活选择和组合这些技术，才能写出既高效又优雅的代码。