StringBuffer方法分析

最新推荐文章于 2024-05-13 13:22:09 发布

Aeolian钦

最新推荐文章于 2024-05-13 13:22:09 发布

阅读量143

点赞数

分类专栏： JAVA String 文章标签： java 字符串

本文链接：https://blog.csdn.net/weixin_45362971/article/details/115493492

版权

JAVA 同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

String

3 篇文章 0 订阅

订阅专栏

类结构

在这里插入图片描述
通过上面这个类图，我们可以发现StringBuffer的类结构并不复杂，他继承了AbstractStringBuilder抽象类，实现了Serializable，CharSequence接口，其中AbstractStringBuilder类又实现了Appendable接口，这些类的作用是什么？
Serializable：这个类其实很简单，就是实现了序列化，序列化就不多叙述了。
Appendable：这个接口定义了几个重载方法，append，这个方法对于我们来说很熟悉，就是实现了字符串拼接。也就是说定义了规范。
CharSquence：该接口提供对许多不同类型的char 序列的统一，只读访问。 char值表示 Basic * Multilingual Plane中的字符或替代。Unicode字符表示形式。
AbstractStringBuilder：这个就是第一层实现，他实现了Appendable接口和CharSquence接口的方法，并且做了许多的扩展。
StringBuffer：在AbstractStringBuilder抽象类的基础上在此进行了扩展。
关于这个就不多说了，我们重点在StringBuffer的内部结构和实现。

属性

StringBuffer本身属性只有一个

private transient char[] toStringCache;

这个是干什么的？
toStringCache，从字面意思上就是toString的缓存，从注释来看，就是toString时的最新的值，在每次修改的时候，toStringCache就要被清除。
在这说下transient 关键字，这个关键字就是注明这个属性不参与序列化。
StringBuffer的值存储在哪？
通过继承我们可以发现，这个存储的变量在他的分类AbstractStringBuffer类中

// 字符串的存放
char[] value;
// 个数
int count;

构造器

StringBuffer的构造器相较于String的构造器要少的多。他的很多方法都是直接调用父类的方法。所以我们要先看看父类的构造器，父类的构造器只有两个，一个无参，一个带int的有参构造器。

	AbstractStringBuilder() {
    }
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

无参构造器对value是没有任何操作的，也就是说他并没有进行初始化，他只在有参构造中进行初始化。
StringBuffer的构造器

	public StringBuffer() {
	// 调用父类的有参构造
        super(16);
    }
    public StringBuffer(int capacity) {
        super(capacity);
    }

通过无参构造器，我们可以知道StringBuffer的value值，默认长度是16.可以指定他的长度。

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

这两个构造函数就是要注意的了，他在初始化的时候，并不是将他的字符串长度作为他的默认长度，而是将字符串长度和他的默认长度相加得到他的实际长度。然后通过append方法将字符串添加进去。

常用方法

append

StringBuffer的append 方法，可以毫不犹豫的说，他充分利用了java面向对象的特性-继承，他每个append方法都是调用父类的append方法来实现，他只是在中间将缓存toStringCache清空。还要注意的是他的append方法都进行了加锁。也就是说他是线程安全的，这也就是为什么说StringBuffer是线程安全的。
除了这个之外，我们要看的主要实现在AbstractStringBuilder中，
其实我们在翻阅源码就会发现，他的实现究竟是怎么样的，他基本分了几个模板对不同的数据类型进行操作，参数类型是String，StringBuilder，StringBuffer是一个模板

	public AbstractStringBuilder append(String str) {
	// 判断这个多少对象是否为空
        if (str == null)
            return appendNull();
            // 获取长度
        int len = str.length();
        // 判断是否能够容纳
        ensureCapacityInternal(count + len);
        // 通过String的getChars方法，底层依旧就是System的arraycopy进行扩展
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

append(CharSequence s)方法，CharSequence是所有字符类型的父类，所有对他要进行他子类的类型判断，

	@Override
    public AbstractStringBuilder append(CharSequence s) {
    // appendNull 方法就是说 如果添加的字符串为null，他不是说不会添加，而是会将null作为字符添加 他是一个私有方法
        if (s == null)
            return appendNull();
            // 调用上面的那种append类型的方法
        if (s instanceof String)
            return this.append((String)s);
            // 因为AbstractStringBuilder是StringBuffer和StringBuilder的父类
        if (s instanceof AbstractStringBuilder)
            return this.append((AbstractStringBuilder)s);
            // 其他情况
        return this.append(s, 0, s.length());
    }

我们可以发现，这方法其实就是通过类型匹配，找到对应的append方法来进行操作。

AbstractStringBuilder append(CharSequence s, int start, int end) 这个方法就是上面的其他情况

	@Override
    public AbstractStringBuilder append(CharSequence s, int start, int end) {
        if (s == null)
            s = "null";
        if ((start < 0) || (start > end) || (end > s.length()))
            throw new IndexOutOfBoundsException(
                "start " + start + ", end " + end + ", s.length() "
                + s.length());
        int len = end - start;
        // 对容器大小判断，扩容等操作
        ensureCapacityInternal(count + len);
        // 一个一个的插入，他是指定开始和结束下标插入的，不再是调用System.arraycopy方法。
        for (int i = start, j = count; i < end; i++, j++)
            value[j] = s.charAt(i);
        // 更新字符串字符个数
        count += len;
        return this;
    }

AbstractStringBuilder append(char[] str) 这个类似于上面的方法，不过他是一次性将str这个字符数组的值插入

	public AbstractStringBuilder append(char[] str) {
        int len = str.length;
        ensureCapacityInternal(count + len);
        // 这里就能调用到这个native方法。
        System.arraycopy(str, 0, value, count, len);
        count += len;
        return this;
    }

AbstractStringBuilder append(char str[], int offset, int len) 方法值str的偏移量offset开始，共插入len长度的字符

	public AbstractStringBuilder append(char str[], int offset, int len) {
        if (len > 0)                
            ensureCapacityInternal(count + len);
        System.arraycopy(str, offset, value, count, len);
        count += len;
        return this;
    }

后面的一些append方法就是一些插入纯字符的操作了，类似于上面的操作，就不多讲了

其实说了这么多，大多数的方法都是AbstractStringBuilder来实现的，StringBuffer只是中间进行了一次封装，没有具体实现功能。所以这之后的方法将是讲解AbstractStringBuilder的方法。

delete

	public AbstractStringBuilder delete(int start, int end) {
	// 对起始和结束位置的下标进行判断
        if (start < 0)
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
        // 如果end的下标大于字符长度，就将end = count
            end = count;
        if (start > end)
            throw new StringIndexOutOfBoundsException();
            // 计算出要移除的字符个数
        int len = end - start;
        if (len > 0) {
        // 将end后面的字符从start下标开始进行赋值覆盖，然后给count赋新的长度值
            System.arraycopy(value, start+len, value, start, count-end);
            count -= len;
        }
        return this;
    }

deleteCharAt

	public AbstractStringBuilder deleteCharAt(int index) {
        if ((index < 0) || (index >= count))
            throw new StringIndexOutOfBoundsException(index);
            // 与delete方法的应用基本一致 这个只是删除指定的下标的单个字符
        System.arraycopy(value, index+1, value, index, count-index-1);
        count--;
        return this;
    }

subString

	public String substring(int start, int end) {
        if (start < 0)
            throw new StringIndexOutOfBoundsException(start);
        if (end > count)
            throw new StringIndexOutOfBoundsException(end);
        if (start > end)
            throw new StringIndexOutOfBoundsException(end - start);
            // 截取start下标开始到end结束的字符串，返回一个String
        return new String(value, start, end - start);
    }

除了这个方法之外，还有个方法也可以截取，不过那个方法方法实际上还是调用了这个方法

	@Override
    public CharSequence subSequence(int start, int end) {
        return substring(start, end);
    }

insert

insert方法就是将指定字符串插入到源字符中，可以指定位置，偏移量，插入字符串的指定长度

	public AbstractStringBuilder insert(int index, char[] str, int offset,
                                        int len)
    {
        if ((index < 0) || (index > length()))
            throw new StringIndexOutOfBoundsException(index);
        if ((offset < 0) || (len < 0) || (offset > str.length - len))
            throw new StringIndexOutOfBoundsException(
                "offset " + offset + ", len " + len + ", str.length "
                + str.length);
        ensureCapacityInternal(count + len);
        // 先将要插入的下标开始的源字符串从指定字符串长度的下标开始插入
        System.arraycopy(value, index, value, index + len, count - index);
        // 覆盖操作，在经过上一轮之后，这个字符串有两段一样的字符串，将第一段覆盖。
        System.arraycopy(str, offset, value, index, len);
        count += len;
        return this;
    }