String StringBuffer StringBuilder 老生常谈

1.String 与 StringBuffer 、 StringBuilder的区别

1. String 字符串常量 而 （StringBuffer 和 StringBuilder 字符串变量）
2. 执行速度上：StringBuilder > StringBuffer > String

String是字符串常量，java的字符串不变性，每当用String操作字符串时，实际上实在不断创建新的字符串对象，老的字符串对象经过GC（垃圾回收操作）回收，而使用StringBuilder和StringBuffer操作字符串实际上是在一个字符串对象上操作的，所以StringBuffer和StringBuilder在速度上是快于String的。

2.StringBuffer 和 StringBuilder的区别

1. StringBuilder是线程非安全的，StringBuffer是线程安全的，String是字符串常量（是不变的）显然是线程安全的。
2. StringBuilder 和 StringBuffer 都继承了AbstractStringBuilder类

 //StringBuffer类中的一些方法的实现，可以看到这些方法都是加了同步锁的，所以StringBuffer是线程安全的
public StringBuffer(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }

    @Override
    public synchronized int length() {
        return count;
    }

    @Override
    public synchronized int capacity() {
        return value.length;
    }

    @Override
    public synchronized void ensureCapacity(int minimumCapacity) {
        super.ensureCapacity(minimumCapacity);
    }

    /**
     * @since      1.5
     */
    @Override
    public synchronized void trimToSize() {
        super.trimToSize();
    }

    /**
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @see        #length()
     */
    @Override
    public synchronized void setLength(int newLength) {
        toStringCache = null;
        super.setLength(newLength);
    }

//StringBuilder类的一些方法的实现，大多直接调用AbstractStringBuilder父类的方法，并没有加同步锁，因此StringBuilder类是非线程安全的
@Override
    public StringBuilder append(long lng) {
        super.append(lng);
        return this;
    }
@Override
    public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder deleteCharAt(int index) {
        super.deleteCharAt(index);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder replace(int start, int end, String str) {
        super.replace(start, end, str);
        return this;
    }

    /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder insert(int index, char[] str, int offset,
                                int len)
    {
        super.insert(index, str, offset, len);
        return this;
    }

3.三者的使用总结

1. 如果要操作少量的数据用 = String
2. 单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3. 多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

4.提一下抽象类和接口

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence

可以看到 StringBuffer继承了抽象类AbstractStringBuilder，并且继承了Serializable和CharSequence接口，那么抽象类和接口的区别是什么？

抽象类可以定义一些子类的公用方法，子类继承了抽象父类后只需要增加新的功能，不需要重写抽象父类中已经存在的方法。super( parameter)(构造函数)、super.function(parameter) （成员函数）

父类接口中只是定义了方法的声明，和常量的定义，子类继承了接口后，需要重写方法。