JAVA深化篇_04——字符串相关类StringBuilder和StringBuffer

字符串相关类

String类代表不可变的字符序列

StringBuilder类和StringBuffer类代表可变字符序列。

这三个类的用法，在笔试面试以及实际开发中经常用到，必须掌握好。

String类源码分析

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

我们发现字符串内容全部存储到value[ ]数组中，而变量value是final类型的，也就是常量(即只能被赋值一次)。 这就是“不可变对象”的典型定义方式。

我们发现在前面学习String的某些方法，比如：substring()是对字符串的截取操作，但本质是读取原字符串内容生成了新的字符串。测试代码如下：

【示例】String类的简单使用

 public class TestString1 {
     public static void main(String[ ] args) {
         String s1 = new String("abcdef");
         String s2 = s1.substring(2, 4);
         // 打印：ab199863
         System.out.println(Integer.toHexString(s1.hashCode()));
         // 打印：c61, 显然s1和s2不是同一个对象
         System.out.println(Integer.toHexString(s2.hashCode()));
     }
 }

 ​

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

【示例】字符串常量拼接时的优化

 public class TestString2 {
     public static void main(String[ ] args) {
         //编译器做了优化,直接在编译的时候将字符串进行拼接
         String str1 = "hello" + " java";//相当于str1 = "hello java";
         String str2 = "hellojava";
         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都是可变的字符序列。

1. StringBuffer 线程安全，做线程同步检查， 效率较低。

2. StringBuilder 线程不安全，不做线程同步检查，因此效率较高。建议采用该类。

· 常用方法列表：

• 重载的public StringBuilder append(…)方法

  可以为该StringBuilder 对象添加字符序列，仍然返回自身对象。

• 方法public StringBuilder delete(int start,int end)

  可以删除从start开始到end-1为止的一段字符序列，仍然返回自身对象。

• 方法public StringBuilder deleteCharAt(int index)

  移除此序列指定位置上的 char，仍然返回自身对象。

• 重载的public StringBuilder insert(…)方法

  可以为该StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。

• 方法public StringBuilder reverse()

  用于将字符序列逆序，仍然返回自身对象。

• 方法public String toString()返回此序列中数据的字符串表示形式。

• 和 String 类含义类似的方法：

 public int indexOf(String str)
 public int indexOf(String str,int fromIndex)
 public String substring(int start)
 public String substring(int start,int end)
 public int length() 
 char charAt(int index)

 ​【示例】StringBuffer/StringBuilder基本用法

public class TestString {

    public static void main(String[] args) {
        //字符串的拼接
        String s = "hello"+"world";
        String s2 = "helloworld";
        System.out.println(s==s2);

        //StringBuilder用法  线程不同步   线程不安全  但效率高
        StringBuilder s1 = new StringBuilder("中国人");
        //append 用法  添加
        System.out.println(s1.append("爱").append("中国"));

        //insert 用法 插入
        System.out.println(s1.insert(0,"今天的"));

        //StringBuffer用法  线程同步  线程安全  效率低
        StringBuffer b2 = new StringBuffer("中国");

        //insert 方法  返回自身 连续插入
        System.out.println(b2.insert(0,"好").insert(0,"常").insert(0,"非"));

        //delete  方法  删除下标在[x,y)的字符
        b2.delete(0,3);
        System.out.println(b2);

        //deletecharAt()   删除某个字符
        b2.deleteCharAt(1);
        System.out.println(b2);

        System.out.println(s1.delete(0,3));

        //reverse 方法  字符串逆序
        System.out.println(s1.reverse());
    }
}

 ​

执行结果如图所示：

StringBuffer和StringBuilder都是可变的字符序列。

1. StringBuffer 线程安全，做线程同步检查， 效率较低。

2. StringBuilder 线程不安全，不做线程同步检查，因此效率较高。建议采用该类。

不可变和可变字符序列使用陷阱

· String使用的陷阱

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

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

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

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

【示例】String和StringBuilder在字符串频繁修改时的效率测试

public class TestString2 {

    public static void main(String[] args) {
        /*使用String进行字符串的拼接*/
        String s1="";
        long num1=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time1= System.currentTimeMillis();//获取系统的当前时间
        for (int i=0;i<5000;i++){
            s1=s1+i;                            //会产生5000个对象
        }
        long num2 = Runtime.getRuntime().freeMemory();
        long time2 = System.currentTimeMillis();
        System.out.println("系统消耗的空间："+(num1-num2));
        System.out.println("系统消耗的时间："+(time2-time1));

        /*使用StringBuildier进行添加字符*/
        StringBuilder s2=new StringBuilder("");
        long num3=Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time3= System.currentTimeMillis();//获取系统的当前时间
        for(int i=0;i<5000;i++){
            s2.append(i);                      //只有这一个对象
        }
        long num4 = Runtime.getRuntime().freeMemory();
        long time4 = System.currentTimeMillis();
        System.out.println("系统消耗的空间："+(num3-num4));
        System.out.println("系统消耗的时间："+(time4-time3));
    }
}

执行结果如图所示：