String类中的常用方法

原创于 2025-05-29 22:21:16 发布 · 1k 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#java

前言

本文介绍Java 中 String 类的常用方法，为什么 String 对象不能被改变，以及 StringBuilder 和 StringBuffer 的区别。

一、String 类的常用方法

1. 常用的构造方法

可以传一个字符串，也可以传一个字符数组：

// 传一个字符串
String str1 = new String("abc");

// 传一个字符数组
char[] array = {'a', 'b', 'c'};
String str2 = new String(array);

2. 字符串的长度

String 类在 java.lang 包里。

求字符串的长度：

length() 方法：str.length();

判断字符串是否为空：

isEmpty() 方法：str.isEmpty()，返回值是 boolean 类型；

注意：长度为 0 就是空；

3. 字符串的比较

equals() 方法：str1.equals(str2)，返回值是 boolean 类型;

注意：equals 是 Object 类的方法，String能使用 equals 比较是因为重写了 equals 的方法.如果是自定义方法，一定要重写 equals 方法，否则只会比较引用变量里面存的哈希值。

compareTo() 方法：str1.compareTo(str2);

str1 大于 str2 返回正数，str1 小于 str2 返回负数，str1 等于 str2 返回 0；

String 类中 compareTo 的比较逻辑：先比较前 k 个字符，返回第一个不同字符的差值，如果前 k 个字符相同，返回字符串长度的差值；

源码如下：

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

compareToIgnoreCase() 方法：忽略大小写进行比较；

4. 字符串的查找

返回指定位置字符：

charAt() 方法：str.charAt(pos)；

返回字符/子串下标：indexOf() 和 lastIndexOf()

indexOf(ch) 返回 ch 字符第一次出现的位置;

indexOf(ch, 3) 从 3 位置开始找 ch 第一次出现的位置；

indexOf(substr) 返回 substr 子串第一次出现的位置；

indexOf(substr, 10) 从 10 位置开始找 substr 第一次出现的位置；

lastIndexOf(ch) 从后往前找，返回 ch 字符第一次出现的位置；

lastIndexOf(ch, 3) 从第 3 个位置开始从后往前找，返回 ch 字符第一次出现的位置；

lastIndexOf(substr) 从后往前找，返回 substr 子串第一次出现的位置；

lastIndexOf(substr, 10) 从第 10 个位置开始从后往前找，返回第一次出现 substr 子串的位置；

5. 字符串转化

String.valueOf()：数字转字符串;

Integer.parseInt()：字符串转整型；

Double.parseDouble()：字符串转双精度；

toUpperCase(): 转成大写字符串；

toLowerCase(): 转成小写字符串；

toCharArray(): 字符串转数组（非常重要）；

String.format():格式化字符串，String.format("%d-%d-%d", 2025, 5, 29);

6. 字符串替换

replace():

replace(String src, String dest): 字符串替换

replace(char src, char dest): 字符替换

replaceFirst(String src, String dest): 替换首个字符串

replaceAll(String src, String dest): 替换所有字符串

7. 字符串拆分

split():

String[] split(String regex): 按照 regex 分割字符串，返回字符串数组

String[] split(String regex, int limit): 按照 regex 分割字符串，分割成 limit 组，返回字符串数组；

正则表达式：

以 “|”，“*”，“+”分割要注意转义，前面加上“\\”；

如果是“\”，要写成“\\\\”;

如果使用多个分隔符分割，需要使用“|”连接分隔符；

注意：如果一次分割不能满足要求，可以考虑多次分割的策略；

8. 字符串截取

substring(int begin, int end): 从 begin 截取到 end - 1，非常重要;

trim(): 去除字符串左右两边的空格；

二、字符串不可变的原因

源码：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    //......
}

原因：

字符串中存字符的字符数组是被 private 修饰的，我们调用 String 对象时是在类外面调用的，无法获取到这个字符数组，因此这个字符数组是没法被修改的。因此所有操作字符串的方法，实际上都是创建了一个新的对象，并没有修改原有的字符串；

类有 final 关键字修饰，不能被继承；

三、StringBuilder 和 StringBuffer

1.StringBuilder 和 StringBuffer 类的常用方法

append() : 在原有对象后面追加内容，可以是字符，字符串，整数，浮点数，字符串...；

setCharAt(int pos): 更改 pos 位置的字符；

insert(int pos, String s): 在 pos 位置插入字符串；

deleteCharAt(int pos): 删除 pos 下标的元素；

substring(int begin, int end): 返回从 begin 到 end - 1 位置的子串；

reverse(): 逆序 StringBuilder 对象；

toString(): 把 StringBuilder 对象转换为字符串；

2. String，StringBuilder 和 StringBuffer 的区别

String 的内容不可修改，StringBuilder 和 StringBuffer 的内容可以修改；

StringBuilder 和 StringBuffer 的大部分功能是相似的；

StringBuilder中的方法没有关键字 synchronized 修饰， StringBuffer中的方法有 synchronized 修饰，在多线程的环境下使用 StringBuffer 有助于确保线程安全，但是如果频繁调用 synchronized 修饰的方法，会降低程序执行的效率。

源码：

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence{

    // ......

    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }

    /**
     * Constructs a string builder that contains the same characters
     * as the specified {@code CharSequence}. The initial capacity of
     * the string builder is {@code 16} plus the length of the
     * {@code CharSequence} argument.
     *
     * @param      seq   the sequence to copy.
     */
    public StringBuilder(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }

    @Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

    // ......
}

 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence{
    
    // ......

    public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }

    /**
     * Constructs a string buffer that contains the same characters
     * as the specified {@code CharSequence}. The initial capacity of
     * the string buffer is {@code 16} plus the length of the
     * {@code CharSequence} argument.
     * <p>
     * If the length of the specified {@code CharSequence} is
     * less than or equal to zero, then an empty buffer of capacity
     * {@code 16} is returned.
     *
     * @param      seq   the sequence to copy.
     * @since 1.5
     */
    public StringBuffer(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }

    @Override
    public synchronized int length() {
        return count;
    }

    @Override
    public synchronized int capacity() {
        return value.length;
    }


    @Override
    public synchronized void ensureCapacity(int minimumCapacity) {
        super.ensureCapacity(minimumCapacity);
    }

    /**
     * @since      1.5
     */
    @Override
    public synchronized void trimToSize() {
        super.trimToSize();
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @see        #length()
     */
    @Override
    public synchronized void setLength(int newLength) {
        toStringCache = null;
        super.setLength(newLength);
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @see        #length()
     */
    @Override
    public synchronized char charAt(int index) {
        if ((index < 0) || (index >= count))
            throw new StringIndexOutOfBoundsException(index);
        return value[index];
    }

    // ......
}