String、StringBuffer与StringBuider的区别联系

痛定思痛。 2021-12-10 13:29 172阅读 0赞

#### 一、 String ####

String是字符串常量，它与`StringBuilder`,`StringBuffer`最大的区别就是，它是一个不可变对象，`String`内部是一个`private final char value[]`数组，每次对String类型进行改变其实都等同于生成了一个新的String对象，然后将指针指向新的String对象，所以经常改变内容的字符串最好不用String。

> 由于创建`String`对象与普通对象一样，每次创建也要耗费大量时间和空间，JVM为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化。为了减少在JVM中创建的字符串的数量，字符串类维护了一个字符串池。然后在创建对象的时候，会先从常量池中检查是否有相同的字符串，如果有那么返回改引用，如果没有则在常量池中创建该字符串实例，然后返回引用。这操作的前提都是因为，字符串对象是不可变，不会发生数据冲突。

**String的长度限制**  
`编译期限制：`由字符串常量池限制，因为常量池的长度由一个 u2 变量(16位)表示，因此理论上允许的的最大长度是2^16=65536。而 java class 文件是使用一种变体UTF-8格式来存放字符的，null 值使用两个 字节来表示，因此只剩下 65536－ 2 ＝ 65534。

String a = "a......a" //存放 65534个a 编译通过
    String a = "b.....b" //存放 65535个b 无法编译通过

`运行期限制`：Integer.MAX\_VALUE ，这个值约等于4G，在运行期，如果String的长度超过这个范围，就可能会抛出异常。

//受 count数值的限制
    public String(char value[], int offset, int count)

#### 二、 StringBuilder与StringBuffer ####

`StringBuffer`与`StringBuilder`非常类似，都用来表示可变字符序列。最大的区别就是，`StringBuilder`更高效，线程不安全。`StringBuffer`属于线程安全的。他们两个都是`AbstractStringBuilder`的子类。  
![在这里插入图片描述][2019071218440396.png]  
因为`StringBuffer`与`StringBuilder`的方法几乎都相同 ，下面以`StringBuilder`它是可变的字符序列业,也维护着一个`char`数组。

abstract class AbstractStringBuilder implements Appendable, CharSequence { 
        /** * The value is used for character storage. */
        char[] value;

但是不同的是，它维护着一个可变的数组，不同与`String`是`final`修饰。当我们使用`new StringBuilder(String str)`创建一个\`StringBuilder对象的时候

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

调用`super`的方法，创建一个`char[]` 长度是 字符串的长度+16

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

然后`append(str)`，追加字符串，每次追加的时候，如果数组的容量不够，就会进行扩容，然后复制内容。

public AbstractStringBuilder append(String str) { 
            if (str == null)
                return appendNull();
            int len = str.length();
            // #ensureCapacityInternal方法
            //1、进行判断是否需要扩容 如果数组长度 小于count + len【原来的容量+要追加字符的容量】
            //扩容操作 创建一个新数组 长度是：value.length * 2 + 2; 原来长度x2 + 2
            //2、将原来值复制到新创建的数组当中 Arrays.copyOf(value, newCapacity)
            ensureCapacityInternal(count + len);
            //将追加的字符串str复制到目标字符数组中。 
            str.getChars(0, len, value, count);
            count += len;
            return this;
        }

**我们对StringBuilder操作，就只创建了一个对象，不会每次操作与String一样都创建一个新的对象**

@Test
        public void test5(){ 
            StringBuilder stringBuilder = new StringBuilder("abc");
            StringBuilder stringBuilder2 = stringBuilder.append("efg");
            System.out.println(stringBuilder==stringBuilder2); //输出 true
    
        }

##### StringBuffer #####

下面是`StringBuffer`的部分方法，都加了`synchronized`锁，这也就是为什么他是线程安全的了。

/** * @since 1.5 */
        @Override
        public synchronized int codePointAt(int index) { 
            return super.codePointAt(index);
        }
    
        /** * @since 1.5 */
        @Override
        public synchronized int codePointBefore(int index) { 
            return super.codePointBefore(index);
        }
    
        /** * @since 1.5 */
        @Override
        public synchronized int codePointCount(int beginIndex, int endIndex) { 
            return super.codePointCount(beginIndex, endIndex);
        }
    
        /** * @since 1.5 */
        @Override
        public synchronized int offsetByCodePoints(int index, int codePointOffset) { 
            return super.offsetByCodePoints(index, codePointOffset);
        }
    
        /** * @throws IndexOutOfBoundsException {@inheritDoc} */
        @Override
        public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
                                          int dstBegin)
        { 
            super.getChars(srcBegin, srcEnd, dst, dstBegin);
        }
    
        /** * @throws IndexOutOfBoundsException {@inheritDoc} * @see #length() */
        @Override
        public synchronized void setCharAt(int index, char ch) { 
            if ((index < 0) || (index >= count))
                throw new StringIndexOutOfBoundsException(index);
            toStringCache = null;
            value[index] = ch;
        }
    
        @Override
        public synchronized StringBuffer append(Object obj) { 
            toStringCache = null;
            super.append(String.valueOf(obj));
            return this;
        }

[2019071218440396.png]: /images/20211210/ac08d1b78cd34abe990c53e1680fc0ac.png