String,StringBuffer,StringBuillder的一些底层实现-优快云博客

本文详细比较了String、StringBuffer和StringBuilder三个字符串类的区别，包括线程安全性、底层实现、执行速度等方面，并提供了测试代码示例。

一、StringBuffer

线程安全

通过synchronized来保证多线程下的数据安全。

     @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }
复制代码

底层通过 char[] 数组实现


    public StringBuffer() {
        super(16);
    }

    public StringBuffer(int capacity) {
        super(capacity);
    }


    public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }
    
    // super(capacity);是父类AbstractStringBuilder 的构造方法
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

复制代码

添加字符串的过程

-->先检查内部char[]数组是否需要扩容

-->如需要扩容则进行扩容，然后将原来元数据copy到新数组中。

-->再将新添加的元数据加入到新char[]数组中

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        //检查char[]数组是否需要扩容，扩容，并将原来的数据copy进去新扩容的数组中
        ensureCapacityInternal(count + len);
        //将新添加的数据添加到StringBuilder中的char[]数组中，实现字符串的添加
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }


/**
*元数组char[]的扩容过程
*/
    void expandCapacity(int minimumCapacity) {
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        value = Arrays.copyOf(value, newCapacity);
    }


/**
*扩容实现
*/
   public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
复制代码

StringBuilder

线程非安全的字符串操作类
字符串的添加没有加同步处理，涉及到数组扩容，容易产生脏数据，破坏数据正确性
底层结构和StringBuffer实现基本一样，只是没有做同步处理。

String

String类没有提供用于修改字符串的方法。

String类对象为不可变字符串，如字符串string=”HELLO”永远只包含HELLO这几个字母，而不能修改其中任何一个字符。当然可以修改字符串变量string的引用，让它引用另一个字符串。

  不可变字符串有一个优点：编译器可以让字符串实现共享。实际上只有字符串常量（使用“ ”声明，存储在字符串常量池中）是共享的，subStrng,+等操作产生的结果不能共享。 
  比较字符串值是否相等时使用equals()方法，不能使用==，==比较的是字符串的地址是否相同。如果字符串在常量池中，可以使用==比较，因为指向的都是同一个字符串。
复制代码

4.三者在执行速度方面的比较：StringBuilder > StringBuffer > String

5.Test.java

public class Test {

    public static void main(String[] args) {
//        String a="abc";
//        String b=new String(a);
//        //【true】a和b比较的是内容。便利各自的char[]数组进行比较
//        System.out.println("a和b比较==>"+a.equals(b));
//        //【false】 a和b比较的是地址。a在常量池中  b在堆内存中
//        System.out.println("a和b比较==>"+a==b);
        
        test02();
        
    }
    
    
    public static void test01(){
        /**
         * 你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：
            String str = “This is only a” + “ simple” + “test”;
            
            其实就是：
            String str = “This is only a simple test”;
            
            所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：
            
             String str2 = “This is only a”;

             String str3 = “ simple”;

             String str4 = “ test”;
            
             String str1 = str2 +str3 + str4;
            
             这时候JVM会规规矩矩的按照原来的方式去做。
         */
    }
    
    
    public static void test02(){
         //string3指向常量池中的字符串second
         //string4指向堆中的字符串second
         //所以值相同，引用不同
         String string3="second";
         String string4=new String("second");
         System.out.println(string3==string4);
         System.out.println(string3.equals(string4));

         //string5指向常量池中的字符串third
         //string6一开始指向堆中的字符串third,但是调用intern()方法之后，且该方法调用时先检查常量池中是否有值为string6
         //的字符串，如果有则返回该字符串的引用，否则在常量池中创建该字符串，并返回引用
         //所以一开始引用不相等，后来相等
         String string5="third";
         String string6=new String("third");
         System.out.println(string5==string6);
         string6=string6.intern();
         System.out.println(string5==string6);
    }
}
复制代码