备案号:蜀ICP备2026035467号-3|网址:www.xservx.com

java字符串方法习题

⚡ 什么是Java字符串?为何它是开发者的必修课?

在Java语言体系中,字符串(String)是最基础、最常用的数据类型之一。它并非基本类型,而是一个不可变的(final)类,属于java.lang包,无需导入即可直接使用。从最简单的控制台输出到复杂的文本处理、网络通信、数据库交互,字符串无处不在。

据2024年开发者生态调研显示,超过87%的Java开发者在日常编码中每天至少处理10次以上的字符串操作。在阿里、腾讯、字节等大厂的后端系统中,字符串处理性能往往成为系统吞吐量的关键瓶颈之一。因此,深入理解String、StringBuilder、StringBuffer的内部机制与适用场景,是Java工程师进阶的基石。

本页面聚焦于java字符串方法习题,不仅涵盖Java 8至Java 21中常用字符串方法的精讲与实战演练,还深入剖析其底层实现原理(如char[]数组存储、hash缓存、substring的视图复用机制),帮助开发者构建系统性认知,避免“知其然,不知其所以然”的困境。

特别提示:从JDK 9起,String内部存储由char[]改为byte[](配合coder字段),以支持紧凑字符串(Compact Strings),大幅降低内存占用。这一变更虽对API无影响,但对内存敏感型应用(如高并发网关、边缘计算节点)具有重要意义。

⚙️ 核心字符串方法全景图

〈Java字符串方法速查表〉

以下为java.lang.String类中最常用、最高频的18个方法分类汇总,涵盖返回值、功能说明、时间复杂度及典型使用场景:

方法签名 功能说明 时间复杂度 典型应用场景
length() 返回字符串长度(字符数) O(1) 循环边界、输入校验
charAt(int index) 获取指定索引处字符 O(1) 逐字符遍历、解析
indexOf(String str) 首次出现子串的位置 O(n×m) 关键字提取、日志匹配
lastIndexOf(String str) 最后出现子串的位置 O(n×m) 路径解析(如获取文件扩展名)
substring(int start, int end) 截取子串(含头不含尾) JDK 6:O(1);JDK 7+:O(n) 字段提取、格式转换
concat(String str) 拼接字符串 O(n+m) 少量拼接(建议用+替代)
equals(Object obj) 内容相等比较(区分大小写) O(n) 配置判断、状态校验
equalsIgnoreCase(String str) 忽略大小写比较 O(n) 用户输入容错处理
startsWith(String prefix) 是否以指定前缀开头 O(m) 协议识别(如http://)
endsWith(String suffix) 是否以指定后缀结尾 O(m) 文件类型判断(如.jpg)
toUpperCase() 转大写 O(n) 统一格式、正则预处理
toLowerCase() 转小写 O(n) 去重、索引构建
trim() 去除首尾空白字符 O(n) 用户输入清洗
replace(char old, char new) 字符替换(全部) O(n) 符号标准化(如' '→'_')
replace(CharSequence target, CharSequence replacement) 子串替换(全部) O(n×m) 模板渲染、敏感词过滤
split(String regex) 按正则分割为数组 O(n) CSV解析、路径拆分
contains(CharSequence s) 是否包含子串 O(n×m) 关键词检测(如XSS防护)
format(String format, Object... args) 格式化字符串 O(n) 日志构造、用户提示

〔深度解析〕substring方法的内存陷阱

在JDK 6及之前版本,substring通过共享原字符串的char[]数组实现,仅调整offset与count字段,因此时间复杂度为O(1)。但这也导致严重问题:若原字符串极大(如100MB),仅截取前10个字符,新字符串仍持有整个大数组的引用,造成内存泄漏。

自JDK 7起,substring改为新建char[]数组(拷贝内容),时间复杂度变为O(n),但彻底解决了内存泄漏风险。示例:

String large = "a".repeat(10_000_000); // 1000万字符
String small = large.substring(0, 10);
// JDK 6:small仍引用large的完整char[](1000万长度)
// JDK 7+:small拥有独立的10长度char[]

因此,若需从超大字符串中提取小片段,推荐使用:new String(large.substring(start, end))强制触发拷贝,避免潜在OOM。

〔特别注意〕==与equals的差异

新手常混淆==(引用地址比较)与equals(内容比较)。例如:

String a = "hello";
String b = "hello";
String c = new String("hello");
System.out.println(a == b);      // true(字符串常量池复用)
System.out.println(a == c);      // false(堆内存新建对象)
System.out.println(a.equals(c)); // true(内容相同)

在JVM中,直接字面量赋值的字符串会被放入String Pool(字符串常量池),实现复用;而new String()总在堆上创建新对象。因此,**字符串内容比较必须使用equals**,否则可能引发逻辑错误。

⚡ java字符串方法习题实战(含详解)

⑴ 题目:判断字符串是否为空或仅含空白

编写方法:boolean isEmptyOrBlank(String str),要求:空引用、空字符串、全空白字符(空格、制表、换行等)均返回true。

public static boolean isEmptyOrBlank(String str) {
    return str == null || str.trim().isEmpty();
}

解析:先判空引用避免NullPointerException;再调用trim()移除首尾空白,最后用isEmpty()(JDK 11+)判断剩余长度是否为0。若需兼容JDK 8,可改用length() == 0。

⑵ 题目:统计子串出现次数

计算str中子串sub出现的次数(允许重叠),如"aaa"中"aa"出现2次。

public static int countOccurrences(String str, String sub) {
    if (str == null || sub == null || sub.isEmpty()) return 0;
    int count = 0, index = 0;
    while ((index = str.indexOf(sub, index)) != -1) {
        count++;
        index++; // 允许重叠:从下一个位置继续
    }
    return count;
}

关键点:indexOf(String, int)支持指定起始索引;重叠匹配时,每次匹配后仅前进1位(非sub.length())。

⑶ 题目:反转字符串(不使用StringBuilder)

实现String reverse(String s),要求原地操作或高效实现。

public static String reverse(String s) {
    if (s == null || s.isEmpty()) return s;
    char[] chars = s.toCharArray();
    for (int i = 0, j = chars.length - 1; i < j; i++, j--) {
        char temp = chars[i];
        chars[i] = chars[j];
        chars[j] = temp;
    }
    return new String(chars);
}

扩展:若允许使用JDK 11+,可直接:new StringBuilder(s).reverse().toString();但面试中常要求手写算法,体现对字符数组操作的理解。

⑷ 题目:去除字符串中重复字符(保留首次出现顺序)

输入"banana"→输出"ban"

public static String removeDuplicates(String s) {
    if (s == null || s.length() < 2) return s;
    StringBuilder sb = new StringBuilder();
    boolean[] seen = new boolean[256]; // ASCII字符集
    for (char c : s.toCharArray()) {
        if (!seen[c]) {
            seen[c] = true;
            sb.append(c);
        }
    }
    return sb.toString();
}

优化思路:若仅含小写字母,可用int位掩码(bitmask)替代boolean[],节省空间;若字符集为Unicode,需用HashSet。

⑸ 题目:验证回文串(仅字母数字,忽略大小写)

如"A man, a plan, a canal: Panama"→true

public static boolean isPalindrome(String s) {
    if (s == null) return false;
    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;
}

考点:双指针法(空间O(1))、跳过非字母数字字符、统一大小写比较。避免创建新字符串,提升效率。

⑹ 题目:实现atoi(字符串转整数)

模拟Integer.parseInt,处理正负号、空格、溢出、非法字符。

public static int myAtoi(String s) {
    if (s == null) return 0;
    s = s.trim();
    if (s.isEmpty()) return 0;
    int sign = 1, i = 0, result = 0;
    if (s.charAt(0) == '-') { sign = -1; i++; }
    else if (s.charAt(0) == '+') i++;
    for (; i < s.length(); i++) {
        char c = s.charAt(i);
        if (c < '0' || c > '9') break;
        // 溢出检查:result > Integer.MAX_VALUE / 10 或 (等于且digit>7)
        if (result > Integer.MAX_VALUE / 10 ||
            (result == Integer.MAX_VALUE / 10 && (c - '0') > 7)) {
            return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
        }
        result = result * 10 + (c - '0');
    }
    return result * sign;
}

陷阱:负数溢出边界为Integer.MIN_VALUE(-2147483648),其绝对值比Integer.MAX_VALUE大1,故比较时需用7而非8。

⚡ 高效字符串处理技巧(实战派)

⑴ 优先用+而非concat

编译器会将"a" + "b"优化为StringBuilder链式调用;而concat需创建新对象且无缓存优化。

⑵ 大量拼接用StringBuilder

循环中拼接100次以上时,StringBuilder性能是+的3-5倍。注意指定初始容量:new StringBuilder(1024)避免扩容。

⑶ 正则匹配用Pattern预编译

split("\\s+")每次调用都编译正则;改用Pattern p = Pattern.compile("\\s+")复用,性能提升10倍。

⑷ 字符串常量池利用

String.intern()可将运行时字符串放入常量池,节省内存(如重复日志前缀),但慎用避免常量池污染。

💡 性能黄金法则:少创建新对象、避免重复计算、预估容量、善用原生API(如Character.isDigit比正则快10倍)。

⚠️ java字符串方法习题常见误区

误区1:认为String是线程安全的

String对象本身不可变,因此是线程安全的;但若在多线程中共享String引用并修改其指向(如str = "new"),仍需同步。核心在于:**不可变性保护对象内容,不保护引用变更**。

误区2:trim()能去除所有空白

trim()仅移除Unicode值≤U+0020的字符(空格、制表、换行等),但不包括Unicode空格(如 )。应使用strip()(JDK 11+)或正则replaceAll("\\s+", "")。

误区3:substring不占内存

如前所述,JDK 7+已修复内存泄漏,但开发者仍误以为其O(1)开销。在处理大文件时,应主动触发拷贝:new String(str.substring(a, b))。

〔高频面试题〕java字符串方法习题

Q1:解释String、StringBuilder、StringBuffer区别

String:不可变,线程安全;StringBuilder:可变,线程不安全,JDK 5+;StringBuffer:可变,线程安全(方法同步),JDK 1.0+。推荐单线程用StringBuilder,多线程用StringBuffer。

Q2:如何高效拼接1000个字符串?

使用StringBuilder并预设容量(如总长度×1.5)。避免:String s = ""; + 循环s += "a"(每次创建新对象,O(n²)复杂度)。

Q3:String s = new String("abc")创建几个对象?

若常量池无"abc":创建2个(池中1个 + 堆中1个);若有:仅创建1个(堆中)。JDK 7+中,new String()始终在堆中创建新对象。

〔问答区〕java字符串方法习题常见问题

Q:为什么String是final的?

A:① 安全性:防止继承篡改行为(如hashCode缓存);② 性能:常量池复用依赖不可变性;③ 线程安全:不可变对象天然线程安全。

Q:如何比较两个字符串是否为变位词(字母相同但顺序不同)?

A:方法1:排序后比较(O(n log n));方法2:统计字符频次(O(n))。示例:int[] count = new int[26];,遍历s加1,遍历t减1,最后全0则为变位词。