浅析我对 String、StringBuilder、StringBuffer 的理解

stringbuilder、stringbuffer 和 string 一样，都是用于存储字符串的。

1、那既然有了 string ，为什么还需要他们两个呢？

原因是 string 是不可变的，它每次的字符串拼接，实际上都会 new 一个新的 string 进行接收。

2、谈谈stringbuilder、stringbuffer他们两个的联系：

我们可以知道 stringbuffer 在 1.0 的时候就发布了,那为什么还需要 stringbuilder 呢？原因是它的大部分方法都上了锁，是线程安全的，导致了效率较低！而我们有时候不需要考虑线程安全问题，追求效率！所以 stringbuilder 在 1.5 的时候就出来了！

3、stringbuilder、stringbuffer 的异同：*

不同：

• stringbuffer 它因为追求安全，给大量方法上锁，线程安全！
• stringbuilder 它因为追求效率，没有给方法上锁，线程不安全！

相同：内部方法和 stringbuffer 完全一致，因为都继承了 abstractstringbuilder，底层数组都是用父类的。

4、源码浅析 string：

结论：final 修饰了底层的字符数组，故内容不可变。

5、源码浅析 stringbuilder：构造方法

观察构造方法：

 public stringbuilder() {
    super(16);
  }

  
  public stringbuilder(int capacity) {
    super(capacity);
  }

  public stringbuilder(string str) {
    super(str.length() + 16);
    append(str);
  }

  public stringbuilder(charsequence seq) {
    this(seq.length() + 16);
    append(seq);
  }

结论：可以看出，它有一个默认的长度 16！而当传入参数是一个字符或者字符串时,它也会自动的传入参数的长度上加上 16！

6、源码浅析 stringbuilder：append 方法

 @override
  public stringbuilder append(object obj) {
    return append(string.valueof(obj));
  }

  @override
  public stringbuilder append(string str) {
    super.append(str);
    return this;
  }

我们发现，它还是调用的父类的 append 方法，说明这个方法他并没有重写，那么 stringbuffer 也一样！

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

结论：我们可以看出，他也是可以拼接 null 的！

 private abstractstringbuilder appendnull() {
    int c = count;
    ensurecapacityinternal(c + 4);
    final char[] value = this.value;
    value[c++] = 'n';
    value[c++] = 'u';
    value[c++] = 'l';
    value[c++] = 'l';
    count = c;
    return this;
  }

然后观察，它接着进行了一个数组容量的判断，而数组的扩容，其实就是在里面实现的，我们点进去看一下！

 private void ensurecapacityinternal(int minimumcapacity) {
    // overflow-conscious code
    if (minimumcapacity - value.length > 0) {
      value = arrays.copyof(value,
          newcapacity(minimumcapacity));
    }
  }

结论：它先是判断，当前数组容量+拼接字符 是否大于 数组长度，如果大于，则进行数组拷贝，并将底层数组的引用指向新数组！

private int newcapacity(int mincapacity) {
    // overflow-conscious code
    int newcapacity = (value.length << 1) + 2;
    if (newcapacity - mincapacity < 0) {
      newcapacity = mincapacity;
    }
    return (newcapacity <= 0 || max_array_size - newcapacity < 0)
      ? hugecapacity(mincapacity)
      : newcapacity;
  }

结论：由此可见，新数组长度扩容为原数组的 2倍+2 ！

问题：那它究竟是怎么拼接字符串的呢？

sb.getchars(0, len, value, count);

进去看一下：string 的 getchars 方法

 public void getchars(int srcbegin, int srcend, char[] dst, int dstbegin)
  {
    if (srcbegin < 0)
      throw new stringindexoutofboundsexception(srcbegin);
    if ((srcend < 0) || (srcend > count))
      throw new stringindexoutofboundsexception(srcend);
    if (srcbegin > srcend)
      throw new stringindexoutofboundsexception("srcbegin > srcend");
    system.arraycopy(value, srcbegin, dst, dstbegin, srcend - srcbegin);
  }

实际调用了一个系统类方法：arraycopy，再点进去看一下！

 public static native void arraycopy(object src, int srcpos,
                    object dest, int destpos,
                    int length);

结论：底层最终是调用的本地方法，实现了的字符数组拷贝，但由于本地方法是可以和操作系统直接打交道的，所以它的 append 字符串拼接效率会高于 string！

总结

到此这篇关于浅析我对 string、stringbuilder、stringbuffer 的理解的文章就介绍到这了,更多相关 string、stringbuilder、stringbuffer 的理解内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！