深入源码剖析String,StringBuilder,StringBuffer

【String,StringBuffer,StringBulider】

 



深入源码剖析String,StringBuilder,StringBuffer
 
【作者：高瑞林】
【博客地址】http://www.cnblogs.com/grl214 
 

写给读者的话

　
　------亲爱的读者感谢您对小编的支持，当我正值青春的年纪里，很高兴能结识了一群花样年华的你们。当幸福像花儿一样盛开，请允许我记住在花季里始终如一关注我的你谢谢您一直在路上！让我们一起带着欢乐走进Java的世界！

目录

 
概述

从实际出发谈论String,StringBuffer,StringBuilder诞生背景

深入源码进行分析

总结

一.概述

　　　首先聊一下String,String表示的是字符串，在String的源码中存在如下：

1 public final class String
2     implements java.io.Serializable, Comparable<String>, CharSequence {
3     /** The value is used for character storage. */
4     private final char value[];

　　由于字符串是由若干个字符线性组成，在java中所有的字符串都可以用数组的形式来存储,由于所声明的数组类型加了final,以至于String成为了一个不可变的字符序列，而在实际的问题中都存在需要字符串变动的情况，针对这一情况，引入了StringBuilder,和StringBuffer，其中StringBuilder是在jdk1.5之后增加的.

二.从实际出发谈论String,StringBuffer,StringBuilder诞生背景

 　　在实际的编程应用，我们经常会涉及到对字符串的一个操作，例如：(增加，删除，截取，替换...),jdk1.0诞生那时的String类是一个封装字符串不可变的，所以在那时只能通过建立临时字符串变量，来对字符串进行增加，删除，截取，替换...,这样的做法使得我们操作的只是临时字符串，而真正的字符串却没有任何变动。既然String是封装不可变数组，那么也得有封装可变数组，就这样StringBuffer诞生了，而且还是线程安全的，由于这种线程安全的StringBuffer在非线程下效率很低，所有jdk1.5之后StringBuilder诞生了，StringBuilder是非线程安全可变字符串类，相比StringBuffer效率很高！

三.深入源码进行分析

　　1、StringBuilder和StringBuffer类的关键源码分析：

1 public final class StringBuilder
2     extends AbstractStringBuilder
3     implements java.io.Serializable, CharSequence
4 {

1 abstract class AbstractStringBuilder implements Appendable, CharSequence {
/**
* The value is used for character storage.
*/
2  char[] value;

 从中可以看出StringBuilder和StringBuffer都继承抽象类AbstractStringBuilder ，所以AbstractStringBuilder
也是它俩共同的父类，并且在父类中声明的数组也是可变的。

2.StringBuilder和StringBuffer默认值问题

 1 public final class StringBuilder
2     extends AbstractStringBuilder
3     implements java.io.Serializable, CharSequence
4 {
5
6     /** use serialVersionUID for interoperability */
7     static final long serialVersionUID = 4383685877147921099L;
8
9     /**
10      * Constructs a string builder with no characters in it and an
11      * initial capacity of 16 characters.
12      */
13     public StringBuilder() {
14         super(16);
15     }
4000

16
17     /**
18      * Constructs a string builder with no characters in it and an
19      * initial capacity specified by the <code>capacity</code> argument.
20      *
21      * @param      capacity  the initial capacity.
22      * @throws     NegativeArraySizeException  if the <code>capacity</code>
23      *               argument is less than <code>0</code>.
24      */
25     public StringBuilder(int capacity) {
26         super(capacity);
27     }

从中可以看出，可变数组的长度大小默认是16，所以如果当长度的大小超过默认值，又会发生什么呢？请看下面代码：　

1 private void ensureCapacityInternal(int minimumCapacity) {
2         // overflow-conscious code
3         if (minimumCapacity - value.length > 0)
4            //调用下面的expandCapacity方法实现“扩容”特性
5             expandCapacity(minimumCapacity);
6     }
7
8    /**
9      * This implements the expansion semantics of ensureCapacity with no
10      * size check or synchronization.
11      */
12     void expandCapacity(int minimumCapacity) {
13        //“扩展”的数组长度是按“扩展”前数组长度的2倍再加上2 byte的规则来扩展
14         int newCapacity = value.length * 2 + 2;
15         if (newCapacity - minimumCapacity < 0)
16             newCapacity = minimumCapacity;
17         if (newCapacity < 0) {
18             if (minimumCapacity < 0) // overflow
19                 throw new OutOfMemoryError();
20             newCapacity = Integer.MAX_VALUE;
21         }
22         //将value变量指向Arrays返回的新的char[]对象，从而达到“扩容”的特性
23         value = Arrays.copyOf(value, newCapacity);
24     }

从上述代码中可以看出当实际数组长度超过默认值时会自动进行扩容，具体是原有数组长度的两倍加2，再不够，再进行扩容！

四.总结

1.并不是任何情况下StringBuilder都一定比String效率高，例如：

　　效率：String>StringBuffer

String str="my"+"name"+"is";
StringBuffer Sb = new StringBuilder(“my”).append(“ name”).append(“ is”);

　　效率：StringBuffer>String

　String S2 = “my name is”;
String S3 = “ gaoruilin”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;

。。。。。。希望这次分享能给读者带来技术上的巩固，谢谢观看！