String StringBuffer StringBuilder 老生常谈

落日映苍穹つ 2022-01-06 18:13 136阅读 0赞

#### 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) （成员函数）

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

转载于:https://www.cnblogs.com/fangpengchengbupter/p/7412828.html