【1】String,StringBuffer,StringBuillder的底层结构研究

1 @Override
2     public synchronized StringBuffer append(String str) {
3         toStringCache = null;
4         super.append(str);
5         return this;
6     }

 1 /**
 2 *无参构造
 3 */
 4 public StringBuffer() {
 5         super(16);
 6 }
 7 
 8 
 9 
10 /**
11 *带参构造
12 */ 
13 public StringBuffer(String str) {
14         super(str.length() + 16);
15         append(str);
16     }
17 
18 /**
19 *初始化char[]数组
20 */
21    AbstractStringBuilder(int capacity) {
22         value = new char[capacity];
23     }

 1 public AbstractStringBuilder append(String str) {
 2         if (str == null)
 3             return appendNull();
 4         int len = str.length();
 5         //检查char[]数组是否需要扩容，扩容，并将原来的数据copy进去新扩容的数组中
 6         ensureCapacityInternal(count + len);
 7         //将新添加的数据添加到StringBuilder中的char[]数组中，实现字符串的添加
 8         str.getChars(0, len, value, count);
 9         count += len;
10         return this;
11     }
12 
13 
14 /**
15 *元数组char[]的扩容过程
16 */
17     void expandCapacity(int minimumCapacity) {
18         int newCapacity = value.length * 2 + 2;
19         if (newCapacity - minimumCapacity < 0)
20             newCapacity = minimumCapacity;
21         if (newCapacity < 0) {
22             if (minimumCapacity < 0) // overflow
23                 throw new OutOfMemoryError();
24             newCapacity = Integer.MAX_VALUE;
25         }
26         value = Arrays.copyOf(value, newCapacity);
27     }
28 
29 
30 /**
31 *扩容实现
32 */
33    public static char[] copyOf(char[] original, int newLength) {
34         char[] copy = new char[newLength];
35         System.arraycopy(original, 0, copy, 0,
36                          Math.min(original.length, newLength));
37         return copy;
38     }

 1 package com.yeepay.sxf.mianshi.pagkage;
 2 
 3 public class StringBufferAndStringBuillder {
 4 
 5     public static void main(String[] args) {
 6 //        String a="abc";
 7 //        String b=new String(a);
 8 //        //【true】a和b比较的是内容。便利各自的char[]数组进行比较
 9 //        System.out.println("a和b比较==>"+a.equals(b));
10 //        //【false】 a和b比较的是地址。a在常量池中  b在堆内存中
11 //        System.out.println("a和b比较==>"+a==b);
12         
13         test02();
14         
15     }
16     
17     
18     public static void test01(){
19         /**
20          * 你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：
21             String str = “This is only a” + “ simple” + “test”;
22             
23             其实就是：
24             String str = “This is only a simple test”;
25             
26             所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：
27             
28              String str2 = “This is only a”;
29 
30 　　　　String str3 = “ simple”;
31 
32 　　　　String str4 = “ test”;
33 
34 　　　　String str1 = str2 +str3 + str4;
35 
36 　　　　这时候JVM会规规矩矩的按照原来的方式去做。
37          */
38     }
39     
40     
41     public static void test02(){
42          //string3指向常量池中的字符串second
43          //string4指向堆中的字符串second
44          //所以值相同，引用不同
45          String string3="second";
46          String string4=new String("second");
47          System.out.println(string3==string4);
48         System.out.println(string3.equals(string4));
49 
50          //string5指向常量池中的字符串third
51          //string6一开始指向堆中的字符串third,但是调用intern()方法之后，且该方法调用时先检查常量池中是否有值为string6
52          //的字符串，如果有则返回该字符串的引用，否则在常量池中创建该字符串，并返回引用
53          //所以一开始引用不相等，后来相等
54          String string5="third";
55          String string6=new String("third");
56          System.out.println(string5==string6);
57          string6=string6.intern();
58          System.out.println(string5==string6);
59     }
60 }