java源码分析~String,StringBuilder（jdk1.5）以及StringBuffer（jdk1.0）这三个类之间有什么区别？

本文链接：https://blog.youkuaiyun.com/qq_38939215/article/details/106070335

String,StringBuilder（jdk1.5）以及StringBuffer（jdk1.0）这三个类之间有什么区别？

共同点：
- 都实现了描述字符串结构的接口可读可写字符串 CharSequence [ length（），chartAt（int index），subSequence（int start,int end）]
- 都实现了Serializable接口
- 类都被final修饰，不可被继承
String继承自Object类
StringBuilder和StringBuffer继承自AbstractStringBuilder类（char[] value）（此类用于实现扩容、append、insert）

运行速度快慢为：StringBuilder > StringBuffer > String

String为字符串常量，String对象一单创建之后该对象不可以改变

    /** The value is used for character storage. */
    private final char value[];

所以，Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。

StringBuilder和StringBuffer的对象是变量，对变量进行操作就是直接对该对象进行更改，而不进行创建和回收的操作，所以速度要比String快很多。
在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

StringBuffer 的所有公开方法都是 synchronized 修饰的， StringBuffer 的所有公开方法都是 synchronized 修饰的。

缓冲区

StringBuffer
    /**
     * A cache of the last value returned by toString. Cleared
     * whenever the StringBuffer is modified.
     */
    private transient char[] toStringCache;
    
    @Override
    public synchronized String toString() {
    if (toStringCache == null) {
        toStringCache = Arrays.copyOfRange(value, 0, count);
    }
    return new String(toStringCache, true);
}
    
         transient 关键字总结
                1）transient修饰的变量不能被序列化；
                
                2）transient只作用于实现 Serializable 接口；
                
                3）transient只能用来修饰普通成员变量字段；
                
                4）不管有没有 transient 修饰，静态变量都不能被序列化；

StringBuilder

@Override
public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}

可以看出，StringBuffer每次获取 toString 都会直接使用缓存区的 toStringCache 值来构造一个字符串。而 StringBuilder 则每次都需要复制一次字符数组，再构造一个字符串。

扩容机制、

无参构造器,默认分配16

public StringBuffer() {
        super(16);    //受父类AbstractStringBuffer控制
    }
AbstractStringBuilder(int capacity) {
        value = new char[capacity];
}

2.有参构造器

public StringBuffer(int capacity) {
        super(capacity);     //指定容量直接赋予长度
    }
    
    //使用字符串创建，字符串长度+16，并且使用append（）方法追加字符串
public StringBuffer(String str) {
        super(str.length() + 16);   
        append(str);
    }
public StringBuffer(CharSequence seq) {
        this(seq.length() + 16); 
        append(seq);
    }
    
AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

3.容量扩充

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int newCapacity = (value.length << 1) + 2;  //"<<"左移"，相当于*2的n次方， 自身长度*2+2
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;     //直接扩容到需要的长度
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)    
            : newCapacity;     //推断是否溢出，若溢出，则将容量设置为整型的最大值
    }
    
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;    //2（ 31-1）-8  确保OutOfMemeoryError