String字符串及StringBuffer、StringBuilder

最新推荐文章于 2021-09-13 10:00:04 发布

机jiajia

最新推荐文章于 2021-09-13 10:00:04 发布

阅读量150

点赞数 1

分类专栏： JAVA基础专栏文章标签： java

本文链接：https://blog.csdn.net/qq_24693613/article/details/109618231

版权

JAVA基础专栏专栏收录该内容

5 篇文章 0 订阅

订阅专栏

String字符串

字符串作为开发中最常使用到的类，也是必须了解熟悉的一个类。

构造方法

构造方法	描述
`String()`	初始化新创建的 `String`对象，使其表示空字符序列。
`String(byte[] bytes)`	通过使用平台的默认字符集解码指定的字节数组来构造新的 `String` 。
`String(byte[] bytes, Charset charset)`	构造一个新的`String`由指定用指定的字节的数组解码charset 。
`String(byte[] bytes, int offset, int length)`	通过使用平台的默认字符集解码指定的字节子阵列来构造新的 `String` 。
`String(byte[] bytes, int offset, int length, Charset charset)`	构造一个新的`String`通过使用指定的指定字节子阵列解码charset 。
`String(char[] value)`	分配一个新的 `String` ，以便它表示当前包含在字符数组参数中的字符序列。
`String(char[] value, int offset, int count)`	分配一个新的 `String` ，其中包含字符数组参数的子阵列中的字符。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];
    //...
}

赋值方式

String str1 = "你好";
String str2 = new String("你好");
String str3 = String.valueOf("你好");

1）直接赋值

2）通过 new 新建 String

3）通过 String.valueOf 创建

匿名字符串

1）通过 " " 包裹的内容都会被解释为字符串，也称为匿名对象（匿名字符串）

地址比较及分析

1）直接赋值

String str1 = "你好";
String str2 = "你好";

System.out.println(str1==str2);

() - > true

如果两个字符串通过直接赋值的话，内容会先被存在字符串池 ( String Pool) 里。再次赋值时会先从字符串池当中去查找，如果存在相同的字符串，则直接引用已有的。如果没有则在池中创建新的字符。

2）通过 new 的方法

String str1 = "你好";
String str2 = new String("你好");

System.out.println(str1==str2);

() - > false

通过 new 关键字创建的对象，不会关心这个字符串是否存在于字符串池当中。即无论是否存在都会在堆内存当中开辟一个新的内存空间。

所以虽然字符串内容一样，但是两个引用所指向的地址是不一样的。

3）String.valueOf (Object obj)

首先先看看 valueOf 的源码

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

这是可以看到 valueOf 这个方法是不会产生新的字符串对象的，它只负责执行 toString() 的方法。

String str1 = "你好";
String str2 = String.valueOf("你好");

System.out.println(str1==str2);

() - > true

所以，经过实践，发现两者对比的结果还是 true 。

常用方法

equals

返回值	方法	描述
`boolean`	`equals(Object anObject)`	将此字符串与指定对象进行比较。
`boolean`	`equalsIgnoreCase(String anotherString)`	将此 `String`与其他 `String`比较，忽略大小写

源码

  public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

分析

通过源码可以看到，String 的 equals 方法就是将 value 数组遍历进行比较，如果有一个字符出现不等的情况就会返回 false 。

charAt

返回值	方法	描述
`char`	`charAt(int index)`	返回 `char`指定索引处的值。

源码

public char charAt(int index) {
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return value[index];
}

分析

这个方法就是从string 内部的 value 数组里拿出第 index 个值。

indexOf

返回值	方法	描述
`int`	`indexOf(int ch)` 。	返回指定字符第一次出现的字符串内的索引
`int`	`indexOf(int ch, int fromIndex)`	返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。
`int`	`indexOf(String str)`	返回指定子字符串第一次出现的字符串内的索引。
`int`	`indexOf(String str, int fromIndex)`	返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。

源码

public int indexOf(int ch, int fromIndex) {
    final int max = value.length;
    if (fromIndex < 0) {
        fromIndex = 0;
    } else if (fromIndex >= max) {
        // Note: fromIndex might be near -1>>>1.
        return -1;
    }

    if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
        // handle most cases here (ch is a BMP code point or a
        // negative value (invalid code point))
        final char[] value = this.value;
        for (int i = fromIndex; i < max; i++) {
            if (value[i] == ch) {
                return i;
            }
        }
        return -1;
    } else {
        return indexOfSupplementary(ch, fromIndex);
    }
}

分析

关键点是在于循环体。通过观察可以发现依旧是遍历依次判断的。

subString

返回值	方法	描述
`String`	`substring(int beginIndex)`	返回一个字符串，该字符串是此字符串的子字符串。
`String`	`substring(int beginIndex, int endIndex)`	返回一个字符串，该字符串是此字符串的子字符串。

源码

public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

分析

可以看到substring其实就是新 new 了一个字符串对象，只不过调用的是三个参数的构造方法。该方法内容如下：

public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

jdk中的解释是：

构造方法	描述
`String(char[] value, int offset, int count)`	分配一个新的 `String` ，其中包含字符数组参数的子阵列中的字符。

是不是看不懂，其实看这个参数的名字就能够推测出来了。

参数	含义
char[] value	需要创建的原字符数组
int offset	创建开始位置
int count	字符数量

即：传入指定的字符数组，从第 offset 位开始，拷贝 count 位字符到新字符串内。

compareTo

返回值	方法名	描述
`int`	`compareTo(String anotherString)`	按字典顺序比较两个字符串。
`int`	compareToIgnoreCase(String str)`	按字典顺序比较两个字符串，忽略病例差异。

通过字典比较字符串 (即 ASCII [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yoD1KRf9-1605074571149)(file:///C:\Users\ADMINI_{1\AppData\LocalLow\Baidu\BAIDUP}1\dict\Default\318FCA~1.PNG)] 比较)，返回一个int 类型

源码

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;
}

分析

1）当两个字符串作比较时，首先测量出两个字符串的长度，然后从第 0 位开始比较，循环次数为长度短的那个字符串长度。

2）每次循环取出两个字符串相同下标的字符，对比两个数，如果两个数不一致，则直接返回两个相差的数值。如果本次比较结果为一致，则进入下次循环。

3）如果当其中长度短的字符串已经遍历完成还没产生结果的话，就直接返回两个字符串长度相减的值。

其他常用方法

返回值	方法	描述
`boolean`	`contains(CharSequence s)`	当且仅当此字符串包含指定的char值序列时才返回true。
`String`	`concat(String str)`	将指定的字符串连接到该字符串的末尾。
`String`	`format(String format, Object... args)`	使用指定的格式字符串和参数返回格式化的字符串。
`byte[]`	`getBytes()`	使用平台的默认字符集将此 `String`编码为字节序列，将结果存储到新的字节数组中。
`boolean`	`matches(String regex)`	告诉这个字符串是否匹配给定的 regular expression 。
`String`	`replaceAll(String regex, String replacement)`	用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。
`String[]`	`split(String regex)`	将此字符串分割为给定的 regular expression的匹配。
`String`	`toUpperCase()`	将所有在此字符 `String`使用默认语言环境的规则大写。
`String`	`toLowerCase()`	将所有在此字符 `String`使用默认语言环境的规则，以小写。
…	…	…

字符拼接工具

可修改的字符串，有以下两种：

StringBuffer

@Override
public synchronized StringBuffer append(String str) {
     toStringCache = null;
     super.append(str);
  	 return this;
}

1）线程安全

2）没有启用字符缓存

3）效率相对于StringBuilder来说较低

StringBuilder

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

1）线程不安全

2）效率相对于StringBuffer来说较高

注意

这二者都继承自 AbstractStringBuilder 这个抽象类，并且 append 都是调用了父类的 append 方法:

public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

总结

1）正常情况下字符串创建之后是不允许被修改的。

2）通过直接赋值方法产生的字符串会先在字符串池中去查找。如果已经有相同的字符串，如果有则不会创建新的字符串，而是直接引用已有的字符串。

3）通过 new 创建的字符串不受字符串池影响。

4）String str=“ab”+“c”; 其实中间产生创建了三个字符串。其中两个（“ab”、“c”）会在 str 创建之后销毁，保留最终结果（“abc”）。

5）字符串与任何类型相加（即拼接字符串）都只能得到字符串结果。

len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}




## 总结

1）正常情况下字符串创建之后是不允许被修改的。

2）通过直接赋值方法产生的字符串会先在字符串池中去查找。如果已经有相同的字符串，如果有则不会创建新的字符串，而是直接引用已有的字符串。

3）通过 new 创建的字符串不受字符串池影响。

4）String str="ab"+"c"; 其实中间产生创建了三个字符串。其中两个（"ab"、"c"）会在 str 创建之后销毁，保留最终结果（"abc"）。

5）字符串与任何类型相加（即拼接字符串）都只能得到字符串结果。

机jiajia

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
String字符串及StringBuffer、StringBuilder

String字符串字符串作为开发中最常使用到的类，也是必须了解熟悉的一个类。构造方法构造方法描述String()初始化新创建的 String对象，使其表示空字符序列。String(byte[] bytes)通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。String(byte[] bytes, Charset charset)构造一个新的String由指定用指定的字节的数组解码charset 。String(byte[] bytes,
复制链接

扫一扫