StringBuffer与StringBuild的区别

约定不等于承诺〃 2022-12-31 14:22 164阅读 0赞

> 前言：What?Why?hoW?
> 
> 1.StringBuffer和StringBuild是什么？它们之间的区别又在哪？
> 
> 2.StringBuffer为什么线程安全？为什么StringBuild更快？
> 
> 3.StringBuffer和StringBuild怎么使用？

1、StringBuffer和StringBuild是什么？它们之间的区别又在哪？

*  都是java.lang包里面的一个公共类(public class)
 *  都继承自AbstractStringBuilder，实现java.io.Serializable, CharSequence
 *  都是主要用于对字符串进行修改，对对象本身进行操作，而不是生成新的对象

// StringBuffer
      java.lang public final class StringBuffer 
          extends AbstractStringBuilder 
          implements java.io.Serializable, CharSequence
      //StringBuild
      java.lang public final class StringBuilder
      	extends AbstractStringBuilder
      	implements java.io.Serializable, CharSequence

![img][]  
2.为什么StringBuffer线程安全，为什么StringBuild更快？

*  StringBuffer中的方法都是通过synchronized来修饰的，同一时间只能被一个线程访问，因此线程安全，也正是因为线程同步，StringBuffer相比StringBuild的效率就会慢一些
 *  以append方法为例：
    
        // 参数类型:
        // Object、String、StringBuffer、AbstractStringBuilder
        // CharSequence
        // CharSequence s, int start, int end
        // char[]、boolean
        // char、int、long、float、double
        @Override
        public synchronized StringBuffer append(Object obj) { 
            toStringCache = null;
            super.append(String.valueOf(obj));
            return this;
        }
        //StringBuild
        public StringBuilder append(Object obj) { 
            super.append(String.valueOf(obj));
            return this;
        }
 *  问题：`toStringCache = null;`的作用是什么？
    
    StringBuffer：toStringCache用transient(意味临时的、短暂的)修饰，表示该变量不会被序列化，在append方法里赋值为null，toString方法中判断如果为空则调用Arrays.copyOfRange，返回copy后的数组
    
    StringBuilder：没有声明toStringCache，toString方法中直接调用Arrays.copyOfRange
    
    从整体上看，StringBuffer和StringBuilder的toString方法没有区别，最后都是返回copy的数组。**那这个被定义出来作为toString返回的最后一个值的缓存，修改StringBuffer时清楚，应该如何理解呢？**
    
        //StringBuffer
        	/** * A cache of the last value returned by toString. Cleared * whenever the StringBuffer is modified. * 意为：toString返回的最后一个值的缓存。修改StringBuffer时清除。 */
        	private transient char[] toStringCache;
        
        	@Override
            public synchronized String toString() { 
                if (toStringCache == null) { 
                    //返回copy的数组
                    toStringCache = Arrays.copyOfRange(value, 0, count);
                }
                return new String(toStringCache, true);
            }
        
        	String(char[] value, boolean share) { 
                // assert share : "unshared not supported";
                // 意为：断言共享：“不支持不共享”
                this.value = value;
            }
        
        //StringBuilder
        	@Override
            public String toString() { 
                // Create a copy, don't share the array
                return new String(value, 0, count);
            }
        
        	public String(char value[], int offset, int count) { 
                if (offset < 0) { 
                    throw new StringIndexOutOfBoundsException(offset);
                }
                if (count <= 0) { 
                    if (count < 0) { 
                        throw new StringIndexOutOfBoundsException(count);
                    }
                    if (offset <= value.length) { 
                        this.value = "".value;
                        return;
                    }
                }
                // Note: offset or count might be near -1>>>1.
                if (offset > value.length - count) { 
                    throw new StringIndexOutOfBoundsException(offset + count);
                }
                this.value = Arrays.copyOfRange(value, offset, offset+count);
            }
        
        	public static char[] copyOfRange(char[] original, int from, int to) { 
                int newLength = to - from;
                if (newLength < 0)
                    throw new IllegalArgumentException(from + " > " + to);
                char[] copy = new char[newLength];
                System.arraycopy(original, from, copy, 0,
                                 Math.min(original.length - from, newLength));
                return copy;
            }

3、StringBuffer和StringBuild怎么使用？

*  常用方法：append()、insert()、delete()、reverse()、replace()
    
        //以StringBuilder为例
        StringBuilder sb = new StringBuilder(10); //给定长度10
        // StringBuilder sb = new StringBuilder(); //对象初始值为空
        // StringBuilder sb = new StringBuilder(“java”);对象初始值为java
        System.out.println(sb.append("Run Bary.."));  
        System.out.println(sb.append("!")); //拼接
        System.out.println(sb.insert(8, " Fast")); //执行下标位置插入
        System.out.println(sb.delete(5,8)); //删除指定下标区间
        System.out.println(sb.reverse()); //反转
        //输出结果如下：
        //Run Bary..
        //Run Bary..!
        //Run Bary Fast..!
        //Run B Fast..!
        //!..tsaF B nuR

### 小结 ###

*  如果要操作少量的数据用 String；
 *  多线程操作字符串缓冲区下操作大量数据 StringBuffer；
 *  单线程操作字符串缓冲区下操作大量数据 StringBuilder。

### 扩展 ###

1、为什么不直接用String通过加号拼接？

*  String类内部所有的字段都是final修饰，值不可变；所有的字段都是私有的；不能够被继承和扩展
 *  每次对String进行修改操作都会赋值给新的对象，原来的对象就不再引用，就会进行回收，这样不仅效率低下，而且消耗大量内存空间。

2、String设计成不可变有什么好处？

*  安全需要：在JDK中Java的类装载机制通过传递的参数（通常是类名）加载类，这些类名在类路径下。假设String是可变的，攻击者可能通过自定义类装载机制损害应用。
 *  性能需要：不可变对象才可以创建常量池，提高JVM性能。
 *  线程安全：当多线程访问时，不可变对象是线程安全的。

3、那有没有什么办法能改变String？

*  通过反射来改变String

> 寄语：若文章中部分知识点或代码理解有误，欢迎指正，共同学习！

[img]: /images/20221120/effd705f58434beda5d4d5678cc10c5d.png