Java - String、StringBuffer与StringBuilder

小咪咪 2022-05-30 05:23 175阅读 0赞

# String、StringBuffer与StringBuilder #

1.  执行速度：StringBuilder > StringBuffer > String
2.  当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
3.  StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
4.  由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

--------------------

# 一、String、StringBuffer与StringBuilder #

## 1.1 String 字符串常量 ##

/** Strings are constant; their values cannot be changed after they * are created. String buffers support mutable strings. * Because String objects are immutable they can be shared. * 字符串是不变的，他们的值在创造后不能改变。 * 字符串缓冲区支持可变字符串，因为字符串对象是不可变的，所以它们可以共享。 * * @see StringBuffer * @see StringBuilder * @see Charset * @since 1.0 */
    public final class String implements Serializable, Comparable<String>, CharSequence { 
       private static final long serialVersionUID = -6849794470754667710L;
       private static final char REPLACEMENT_CHAR = (char) 0xfffd;

在Java Doc文档注释汇总归纳了`String`的两个特点：

*  String是值不可变(immutable)的常量，是线程安全的(can be shared)。
 *  String类使用了final修饰符，String类是不可继承的。

## 1.2 StringBuffer字符串变量（线程安全）是一个容器，最终会通过toString方法变成字符串； ##

public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, Appendable, CharSequence { 
        /** * Constructs a string buffer with no characters in it and an * initial capacity of 16 characters. */
        public StringBuffer() {
            super(16);
        }
        public synchronized StringBuffer append(int i) {
            super.append(i);
            return this;
        }
        public synchronized StringBuffer delete(int start, int end) {
            super.delete(start, end);
            return this;
        }
    }

*  `StringBuffer`是线程安全的可变的，因此当应用程序要求线程安全的时候，则必须使用`StringBuffer`类。

StringBuffer类主要支持的方法为：

<table> 
 <tbody> 
  <tr> 
   <th> 序号</th> 
   <th> 方法描述</th> 
  </tr> 
  <tr> 
   <td> 1</td> 
   <td> public StringBuffer append(String s)<br> 将指定的字符串追加到此字符序列。</td> 
  </tr> 
  <tr> 
   <td> 2</td> 
   <td> public StringBuffer reverse()<br> &nbsp;将此字符序列用其反转形式取代。</td> 
  </tr> 
  <tr> 
   <td> 3</td> 
   <td> public delete(int start, int end)<br> 移除此序列的子字符串中的字符。</td> 
  </tr> 
  <tr> 
   <td> 4</td> 
   <td> public insert(int offset, int i)<br> 将 <code>int</code> 参数的字符串表示形式插入此序列中。</td> 
  </tr> 
  <tr> 
   <td> 5</td> 
   <td> replace(int start, int end, String str)<br> 使用给定 <code>String</code> 中的字符替换此序列的子字符串中的字符。</td> 
  </tr> 
 </tbody> 
</table>

## 1.3 StringBuilder 字符串变量（非线程安全） ##

public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, Appendable, CharSequence { 
       public StringBuilder() {
            super(16);
       }
       public StringBuilder append(String str) {
            super.append(str);
            return this;
        }
        public StringBuilder delete(int start, int end) {
            super.delete(start, end);
            return this;
        }
    }

java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

# 二、String与StringBuffer区别 #

## 2.1 在修改时对象自身是否可变（主要区别） ##

1.  String在修改时不会改变对象自身  
    在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String 。
    
        String str = "abc";//地址str1
        str = "def";//地址str2
2.  StringBuffer在修改时会改变对象自身  
    每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。StringBuffer 上的主要操作是 append 和 insert 方法。
    
        StringBuffer strBuffer = new StringBuffer("abc");//地址strBuffer,值是abc
        strBuffer.append("def");//地址strBuffer,值是abcdef

## 2.2 可变测试 ##

public class MyTest {
        public static void main(String[] args) {
            String str = "abc";
            StringBuffer strBuffer = new StringBuffer();
    
            strBuffer.append("def");
            System.out.println(a.getClass() + "@" + str.hashCode());
            System.out.println(b.getClass() + "@" + strBuffer.hashCode());
    
            str = "aaa";
            strBuffer.append("bbb");
    System.out.println(a.getClass() + "@" + str.hashCode());
            System.out.println(b.getClass() + "@" + strBuffer.hashCode());
        }
    }

**结果：**  
![此处输入图片的描述][20160714183248761]

从图片中可以发现：String的地址已改变，对象已经改变为另一个；StringBuffer地址不变，还是同样的对象。

## 2.3 初始化区别 ##

1.  String
    
        StringBuffer s = null;   
        StringBuffer s = "abc";
2.  StringBuffer
    
        StringBuffer s = null; //结果警告：Null pointer access: The variable result can only be null at this location
        StringBuffer s = new StringBuffer();//StringBuffer对象是一个空的对象
        StringBuffer s = new StringBuffer("abc");//创建带有内容的StringBuffer对象,对象的内容就是字符串"abc"

## 2.4 StringBuffer对象和String对象之间的互转 ##

StringBuffer和String属于不同的类型，也不能直接进行强制类型转换。StringBuffer对象和String对象之间的互转的代码如下：

tring s = "abc";
    StringBuffer sb1 = new StringBuffer("123");
    StringBuffer sb2 = new StringBuffer(s);   //String转换为StringBuffer
    String s1 = sb1.toString();              //StringBuffer转换为String

## 2.5 StringBuffer相对String偏重 ##

StringBuffer类中的方法主要偏重于对于字符串的变化，例如追加、插入和删除等，常用方法有：append方法、insert方法、deleteCharAt方法、reverse方法等。

## 2.6 总结 ##

1.  如果要操作少量的数据用 String；
2.  （多线程下）经常需要对一个字符串进行修改，例如追加、插入和删除等操作，使用StringBuffer要更加适合一些。

# 三、StringBuffer与StringBuilder区别 #

## 3.1 StringBuilder是可变的对象，是5.0新增的 ##

此类提供一个与StringBuffer兼容的 API，但不保证同步。该类被设计用作StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

## 3.2 线程安全性 ##

1.  StringBuffer：线程安全的；
2.  StringBuilder：线程非安全的。

# 四、String,StringBuffer与StringBuilder速度区别 #

## 4.1 在大部分情况下，StringBuffer > String ##

由于String对象不可变，重复新建对象；StringBuffer对象可变。

## 4.2 StringBuilder > StringBuffer ##

当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的。

## 4.3 特殊情况， String > StringBuffer ##

//String效率是远要比StringBuffer快的：
    String S1 = "This is only a" + " simple" + " test";
    StringBuffer Sb = new StringBuilder("This is only a").append("simple").append(" test");

//String速度是非常慢的：
    String S2 = "This is only a";
    String S3 = " simple";
    String S4 = " test";
    String S1 = S2 +S3 + S4;

# 五、总结 #

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

--------------------

参考资料：

1.  [http://blog.csdn.net/chenliguan/article/details/51911906][http_blog.csdn.net_chenliguan_article_details_51911906]
2.  [http://www.runoob.com/java/java-stringbuffer.html][http_www.runoob.com_java_java-stringbuffer.html]

[20160714183248761]: /images/20220530/0e259b2aada64e95a079622789c32366.png
[http_blog.csdn.net_chenliguan_article_details_51911906]: http://blog.csdn.net/chenliguan/article/details/51911906
[http_www.runoob.com_java_java-stringbuffer.html]: http://www.runoob.com/java/java-stringbuffer.html