从零开始学java（三十五）--String类源码分析，StringBuffer和StringBuilder

String类源码分析

String 类对象代表不可变的Unicode字符序列，因此我们可以将String对象称为“不可变对象”。 那什么叫做“不可变对象”呢?指的是对象内部的成员变量的值无法再改变。

String类源码

我们写的字符串序列，会被保存在value[]中，可以看见有修饰符final，只能赋值一次，因此为“不可变对象“。

在遇到字符串常量之间的拼接时，编译器会做出优化，即在编译期间就会完成字符串的拼接。因此，在使用==进行String对象之间的比较时，我们需要特别注意。

public class TestString2 {
    public static void main(String[] args) {
        //编译器做了优化,直接在编译的时候将字符串进行拼接
        String str1 = "hello" + " java";//相当于str1 = "hello java";
        String str2 = "hello java";
        System.out.println(str1 == str2);//true
        String str3 = "hello";
        String str4 = " java";
        //编译的时候不知道变量中存储的是什么,所以没办法在编译的时候优化
        String str5 = str3 + str4;
        System.out.println(str2 == str5);//false
    }
}

StringBuffer和StringBuilder

StringBuffer和StringBuilder非常类似，均代表可变的字符序列。 这两个类都是抽象类AbstractStringBuilder的子类，方法几乎一模一样。我们打开AbstractStringBuilder的源码。

AbstractStringBuilder 部分源码

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char value[];
//以下代码省略
}

那两者有什么区别呢?

  1. StringBuffer JDK1.0版本提供的类，线程安全，做线程同步检查， 效率较低。

  2. StringBuilder JDK1.5版本提供的类，线程不安全，不做线程同步检查，效率较高。
  一般情况下建议采用该类。

StringBuffer和StringBuilder的常用方法

package String类.Test;
/**
 * 测试StringBuilder,StringBuffer可变字符序列
 * @author 与猫子
 *
 */
public class TestStringBuilder2 {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();
		
		for(int tag=0;tag<26;tag++) {
			
			//append方法可以往数组尾部累加元素
			//（我记得我大学上的C语言数据结构有过这个单词）
			char temp=(char)('a'+tag);
			sb.append(temp);
		}
		System.out.println(sb);
		
		//reverse()将字符串进行倒序操作
		sb.reverse();
		System.out.println(sb);
		
		sb.setCharAt(0,	'猫');
		System.out.println(sb);
		
		//insert()在指定下标处插入字符
		//因为insert（）方法返回的对象是调用该方法的对象本身
		//因此可以链式调用；使用原则：方法返回的是调用方法的对象本身
		sb.insert(1, '子');
		System.out.println(sb);
		sb.insert(0, '与').insert(3, '帅');
		System.out.println(sb);
		
		
		//delete()删除某个区间的字符
		sb.delete(0, 3);
		System.out.println(sb);
		//deleteCharAt()删除某个标签处的字符
		sb.deleteCharAt(0);
		System.out.println(sb);
	}
}

可变字符序列（StringBuffer/StringBuilder）与不可变字符序列（String）的使用陷阱

String一经初始化后，就不会再改变其内容了。对String字符串的操作实际上是对其副本(原始拷贝)的操作，原来的字符串一点都没有改变。比如：

String s =“a”; 创建了一个字符串

s = s+“b”; 实际上原来的"a"字符串对象已经丢弃了，现在又产生了另一个字符串s+“b”(也就是"ab")。 如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的时间和空间性能，甚至会造成服务器的崩溃。

相反，StringBuilder和StringBuffer类是对原字符串本身操作的，可以对字符串进行修改而不产生副本拷贝或者产生少量的副本。因此可以在循环中使用。
测试代码

public class Test {
    public static void main(String[] args) {
        /**使用String进行字符串的拼接*/
        
        //本质上使用StringBuilder拼接, 但是每次循环都会生成一个StringBuilder对象
        long num1 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time1 = System.currentTimeMillis();//获取系统的当前时间
        //=============================================================
        //=============================================================
        //以下为主要要理解的地方
        String str8 = "";//创建了一个对象，保存空字符串
        for (int i = 0; i < 5000; i++) {
            str8 = str8 + i;//相当于产生了10000个对象

			//第一次循环：创建一个新str8，把旧str8（这里为空字符）+i赋给新str8
				//在这个过程中int类型的i也会创建一个字符串对象副本，
				//我们赋的是字符串副本的值，
				//这个过程一共产生了2个新的对象，新str8和i的字符串副本
				//以此类推，循环5000辞，就有1w个新对象，占用大量资源
        }
        //=============================================================
        //=============================================================
        long num2 = Runtime.getRuntime().freeMemory();
        long time2 = System.currentTimeMillis();
        System.out.println("String占用内存 : " + (num1 - num2));
        System.out.println("String占用时间 : " + (time2 - time1));
        /**使用StringBuilder进行字符串的拼接*/
        StringBuilder sb1 = new StringBuilder("");
        long num3 = Runtime.getRuntime().freeMemory();
        long time3 = System.currentTimeMillis();
        for (int i = 0; i < 5000; i++) {
            sb1.append(i);
        }
        long num4 = Runtime.getRuntime().freeMemory();
        long time4 = System.currentTimeMillis();
        System.out.println("StringBuilder占用内存 : " + (num3 - num4));
        System.out.println("StringBuilder占用时间 : " + (time4 - time3));
    }
}

运行结果示例

可以看见，String要占用的内存远比StringBuilder多得多。