Java中String类有哪些常见用法

Java中的String类用于表示字符串，是Java核心类库的重要组成部分，其内部基于字符数组实现，且被设计为不可变类，一旦创建就无法修改其内容。String类提供了大量实用方法，覆盖字符串的创建、查询、修改、比较等各类操作场景。

String类的常见创建方式

创建String对象有两种常用方式，不同的创建方式在内存中的存储逻辑存在差异：

• 字面量赋值：直接将字符串常量赋值给String变量，内容会存储在字符串常量池中，相同内容的字面量会复用同一个对象。
• 构造方法创建：通过new String()构造方法创建对象，会在堆内存中生成新的对象，即使内容和常量池中的已有字符串一致，也不会复用。

下面是两种创建方式的示例代码：

public class StringCreateDemo {
    public static void main(String[] args) {
        // 字面量方式创建
        String str1 = "hello";
        String str2 = "hello";
        // 构造方法方式创建
        String str3 = new String("hello");
        String str4 = new String("hello");
        
        // 输出比较结果：true，说明str1和str2指向同一个对象
        System.out.println(str1 == str2);
        // 输出比较结果：false，说明str3和str4是不同的堆对象
        System.out.println(str3 == str4);
        // 输出比较结果：true，说明内容一致
        System.out.println(str1.equals(str3));
    }
}

String类的常用核心方法

String类提供了丰富的成员方法，以下是最常用的几类：

字符串查询相关方法

• length()：返回字符串的长度，即字符的个数。
• charAt(int index)：返回指定索引位置的字符，索引从0开始。
• indexOf(String str)：返回指定子字符串第一次出现的索引，不存在则返回-1。
• contains(CharSequence s)：判断字符串是否包含指定的字符序列，返回布尔值。

字符串修改相关方法

由于String是不可变的，所有修改操作都会返回新的String对象，原对象不会改变：

• substring(int beginIndex, int endIndex)：截取指定索引范围的子字符串，包含beginIndex，不包含endIndex。
• concat(String str)：将指定字符串拼接到当前字符串末尾，返回新字符串。
• replace(CharSequence oldChar, CharSequence newChar)：替换字符串中所有匹配的子序列，返回新字符串。
• toUpperCase()/toLowerCase()：将字符串转为全大写或全小写，返回新字符串。
• trim()：去除字符串首尾的空白字符，返回新字符串。

以下是上述方法的代码示例：

public class StringMethodDemo {
    public static void main(String[] args) {
        String str = "  Hello Java World  ";
        // 长度
        System.out.println("长度：" + str.length());
        // 取索引为6的字符
        System.out.println("索引6的字符：" + str.charAt(6));
        // 查找Java首次出现的位置
        System.out.println("Java首次出现位置：" + str.indexOf("Java"));
        // 是否包含World
        System.out.println("是否包含World：" + str.contains("World"));
        
        // 截取子串，从7到11
        String subStr = str.substring(7, 11);
        System.out.println("截取子串：" + subStr);
        // 拼接字符串
        String concatStr = str.concat("!!!");
        System.out.println("拼接后：" + concatStr);
        // 替换空格
        String replaceStr = str.replace(" ", "-");
        System.out.println("替换后：" + replaceStr);
        // 转大写
        System.out.println("转大写：" + str.toUpperCase());
        // 去首尾空白
        System.out.println("去空白后：" + str.trim());
    }
}

字符串比较的正确方式

很多初学者会误用==比较字符串内容，实际上==比较的是对象的内存地址，而字符串内容比较需要使用equals()方法：

• equals(Object anObject)：比较字符串的内容是否完全一致，区分大小写。
• equalsIgnoreCase(String anotherString)：比较字符串内容是否一致，不区分大小写。

代码示例：

public class StringCompareDemo {
    public static void main(String[] args) {
        String a = "abc";
        String b = new String("abc");
        String c = "ABC";
        
        // ==比较地址，false
        System.out.println(a == b);
        // equals比较内容，true
        System.out.println(a.equals(b));
        // equalsIgnoreCase比较，不区分大小写，true
        System.out.println(a.equalsIgnoreCase(c));
    }
}

字符串拼接的最佳实践

String是不可变的，频繁使用+拼接字符串会产生大量临时对象，影响性能，不同场景的拼接方案如下：

• 少量固定字符串拼接：直接使用+即可，编译器会自动优化为StringBuilder操作。
• 循环内或大量字符串拼接：使用StringBuilder（非线程安全，性能高）或StringBuffer（线程安全，性能略低）。

拼接示例：

public class StringJoinDemo {
    public static void main(String[] args) {
        // 少量拼接
        String s1 = "hello" + " " + "world";
        System.out.println(s1);
        
        // 循环内拼接，使用StringBuilder
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) {
            sb.append("第").append(i).append("次;");
        }
        String result = sb.toString();
        System.out.println(result);
    }
}

String类的不可变性特性

String类被final修饰，且其内部的字符数组也被final修饰，因此String对象一旦创建就无法修改内容。不可变性带来了以下好处：

• 字符串常量池的复用，减少内存开销。
• 线程安全，多线程环境下无需加锁即可安全使用。
• 可以作为HashMap的键，因为内容不可变，哈希值不会发生变化。

需要注意的是，对String对象的任何修改操作，都会生成新的String对象，原对象不会被改变，这一点在使用时需要注意避免不必要的对象创建。

StringJava字符串操作equalsStringBuilder修改时间：2026-06-19 13:24:19