Java中的String，StringBuffer，StringBuilder区别

- 日理万妓 2022-06-17 09:27 166阅读 0赞

String(大姐，出生于JDK1.0时代) 不可变字符序列  
StringBuffer(二姐，出生于JDK1.0时代) 线程安全的可变字符序列  
StringBuilder(小妹，出生于JDK1.5时代) 非线程安全的可变字符序列

String源码：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence { 
    
        private final char value[];
    
    ｝

StringBuilder源码：

public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence { 
    
        public StringBuilder() {
            super(16);
        }
    
        public StringBuilder(int capacity) {
            super(capacity);
        }
    
        public StringBuilder(String str) {
            super(str.length() + 16);
            append(str);
        }
        @Override
        public StringBuilder append(Object obj) {
            return append(String.valueOf(obj));
        }
        @Override
        public StringBuilder append(String str) {
            super.append(str);
            return this;
        }
    
        public StringBuilder append(StringBuffer sb) {
            super.append(sb);
            return this;
        }

StringBuffer源码：

public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequence { 
        private transient char[] toStringCache;
    
        public StringBuffer() {
            super(16);
        }
    
        public StringBuffer(int capacity) {
            super(capacity);
        }
    
        public StringBuffer(String str) {
            super(str.length() + 16);
            append(str);
        }
    
      @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;
        }
        @Override
        public synchronized StringBuffer append(String str) {
            toStringCache = null;
            super.append(str);
            return this;
        }
    ｝

(1) String中的是常量(final)数组，只能被赋值一次。  
比如：new String(“abc”)使得value\[\]=\{‘a’,’b’,’c’\}(查看jdk String 就是这么实现的)，之后这个String对象中的value\[\]再也不能改变了。这也正是大家常说的，String是不可变的原因 。  
注意：这个对初学者来说有个误区，有人说String str1=new String(“abc”); str1=new String(“cba”);不是改变了字符串str1吗？那么你有必要先搞懂对象引用和对象本身的区别。这里我简单的说明一下，对象本身指的是存放在堆空间中的该对象的实例数据(非静态非常量字段)。而对象引用指的是堆中对象本身所存放的地址，一般方法区和Java栈中存储的都是对象引用，而非对象本身的数据。

(2) StringBuffer中的value\[\]就是一个很普通的数组，而且可以通过append()方法将新字符串加入value\[\]末尾。这样也就改变了value\[\]的内容和大小了。  
比如：new StringBuffer(“abc”)使得value\[\]=\{‘a’,’b’,’c’,”,”…\}(注意构造的长度是str.length()+16)。如果再将这个对象append(“abc”)，那么这个对象中的value\[\]=\{‘a’,’b’,’c’,’a’,’b’,’c’,”….\}。这也就是为什么大家说 StringBuffer是可变字符串 的涵义了。从这一点也可以看出，StringBuffer中的value\[\]完全可以作为字符串的缓冲区功能。其累加性能是很不错的，在后面我们会进行比较。

总结，讨论String和StringBuffer可不可变。本质上是指对象中的value\[\]字符数组可不可变，而不是对象引用可不可变。

（3）StringBuffer与StringBuilder的线程安全性问题  
StringBuffer和StringBuilder可以算是双胞胎了，这两者的方法没有很大区别。但在线程安全性方面，StringBuffer允许多线程进行字符操作。这是因为在源代码中StringBuffer的很多方法都被关键字synchronized 修饰了，而StringBuilder没有。

注意：是不是String也不安全呢？事实上不存在这个问题，String是不可变的。线程对于堆中指定的一个String对象只能读取，无法修改。

★String和StringBuffer的效率问题（这可是个热门话题呀!）  
首先说明一点：StringBuffer和StringBuilder可谓双胞胎，StringBuilder是1.5新引入的，其前身就是StringBuffer。StringBuilder的效率比StringBuffer稍高，如果不考虑线程安全，StringBuilder应该是首选。另外，JVM运行程序主要的时间耗费是在创建对象和回收对象上。

(1) String常量与String变量的”+”操作比较  
原因：测试①的”Heart”+”Raid”在编译阶段就已经连接起来，形成了一个字符串常量”HeartRaid”，并指向堆中的拘留字符串对象。运行时只需要将”HeartRaid”指向的拘留字符串对象地址取出1W次，存放在局部变量str中。这确实不需要什么时间。  
测试②中局部变量s1和s2存放的是两个不同的拘留字符串对象的地址。然后会通过下面三个步骤完成“+连接”：  
1、StringBuilder temp=new StringBuilder(s1)，  
2、temp.append(s2);  
3、str=temp.toString();  
我们发现，虽然在中间的时候也用到了append()方法，但是在开始和结束的时候分别创建了StringBuilder和String对象。可想而知：调用1W次，是不是就创建了1W次这两种对象呢？不划算。

(2)String对象的”累+”连接操作与StringBuffer对象的append()累和连接操作比较。  
结论：大量字符串累加时，StringBuffer的append()效率远好于String对象的”累+”连接  
原因：测试① 中的s=s+s1，JVM会利用首先创建一个StringBuilder，并利用append方法完成s和s1所指向的字符串对象值的合并操作，接着调用StringBuilder的 toString()方法在堆中创建一个新的String对象，其值为刚才字符串的合并结果。而局部变量s指向了新创建的String对象。  
因为String对象中的value\[\]是不能改变的，每一次合并后字符串值都需要创建一个新的String对象来存放。循环1W次自然需要创建1W个String对象和1W个StringBuilder对象，效率低就可想而知了。

测试②中sb.append(s1);只需要将自己的value[]数组不停的扩大来存放s1即可。循环过程中无需在堆中创建任何新的对象。效率高就不足为奇了。

总结：  
(1) 在编译阶段就能够确定的字符串常量，完全没有必要创建String或StringBuffer对象。直接使用字符串常量的”+”连接操作效率最高。  
(2) StringBuffer对象的append效率要高于String对象的”+”连接操作。  
(3) 不停的创建对象是程序低效的一个重要原因。那么相同的字符串值能否在堆中只创建一个String对象那。显然拘留字符串能够做到这一点，除了程序中的字符串常量会被JVM自动创建拘留字符串之外，调用String的intern()方法也能做到这一点。当调用intern()时，如果常量池中已经有了当前String的值，那么返回这个常量指向拘留对象的地址。如果没有，则将String值加入常量池中，并创建一个新的拘留字符串对象。