面试系列之String、String Buffer和StringBuilder

最新推荐文章于 2024-06-27 15:25:28 发布

Java藏宝阁

最新推荐文章于 2024-06-27 15:25:28 发布

阅读量549

点赞数

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/lgy_2021/article/details/124742549

版权

Java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

String:适用于少量的字符串操作

StringBuilder：适用于单线程下在字符串缓冲区进行大量操作

StringBuffer：适用于多线程下在字符串缓冲区进行大量操作

区别一：

String是final类不能被继承且为字符串常量，而StringBuilder和StringBuffer都是字符串变量。

字符串常量是不能改变的，但是字符串对象可以改变，改变的是其内存地址的指向。

StringBuffer和StringBuilder类型是字符串变量，适用append操作时，内存地址不发生改变。

public class StringTest {
  public static void main(String[] args) {

    String str = "aaa";
    System.out.println("字符串常量str的初始地址：" + str.hashCode());
    str = str + "666";
    System.out.println("字符串常量str的修改后地址：" + str.hashCode());
    System.out.println("*****************************************");

    StringBuilder builder = new StringBuilder();
    builder.append("xxxx");
    System.out.println("字符串变量StringBuilder的初始地址：" + builder.hashCode());
    builder.append("yyyyyy");
    System.out.println("字符串变量StringBuilder的修改后地址：" + builder.hashCode());

    System.out.println("*****************************************");
    StringBuffer buffer = new StringBuffer();
    buffer.append("cccc");
    System.out.println("字符串变量StringBuffer的初始地址：" + buffer.hashCode());
    buffer.append("ddddd");
    System.out.println("字符串变量StringBuffer的修改后地址：" + buffer.hashCode());
    
  }
}

输出结果：

区别二：

String可以通过append方法转换成StringBuffer和StringBuilder

StringBuffer和StringBuilder通过toString方法可以转换成String

public class StringBuilderTest {
  public static void main(String[] args) {

    String str = "aaaa";
    StringBuilder stringBuilder = new StringBuilder(str);
    StringBuffer stringBuffer = new StringBuffer(str);
    //输出
    System.out.println(str.getClass() + ":" + str);
    System.out.println(stringBuilder.getClass() + ":" + stringBuilder);
    System.out.println(stringBuffer.getClass() + ":" + stringBuffer);

    System.out.println("***********************************************");
    StringBuffer buffer = new StringBuffer("xxxx");
    StringBuilder builder = new StringBuilder("yyyy");
    String str1 =  buffer.toString();
    String str2 =  builder.toString();
    System.out.println(str1.getClass() + ":" + str1);
    System.out.println(str2.getClass() + ":" + str2);
  }
}

输出结果：

区别三：

线程安全性方面

StringBuilder非线程安全，用在单线程中，性能比StringBuffer要快。

StringBuffer线程安全，可用在多线程中，使用synchronized保证线程安全，执行速度慢。

区别四：

String用“+”作用数据连接符

StringBuffer和StringBuilder用append()连接数据

由于String是不可变的，导致每次对String的操作都会生成新的String对象，效率低，而且浪费大量的内存空间。

StringBuffer和StringBuilder都是可变的，对此进行多次修改，不会产生新的对象，有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量。当字符串大小超过容量时，会自动增加容量，不会产生新的对象。

我们看下String和StringBuffer的部分源码：

//String   
public final class String  
{  
    private final char value[];  
     public String(String original) {  
          // 把原字符串original切分成字符数组并赋给value[];  
     }  
}  
  
//StringBuffer   
public final class StringBuffer extends AbstractStringBuilder  
 {  
 char value[]; //继承了父类AbstractStringBuilder中的value[]  
 public StringBuffer(String str) { 
 //继承父类的构造器，并创建一个大小为str.length()+16的value[]数组 
 super(str.length() + 16);  
 append(str); //将str切分成字符序列并加入到value[]中  
 }  
}

很显然，String和StringBuffer中的value[]都用于存储字符序列，但是String是常量final数组，只能被赋值一次。

比如：new String("abc")其中value[]={'a','b','c'}，之后这个String对象中的value[]再也不能改变了。这也正是大家常说的，String是不可变的原因。

StringBuffer中的value[]是一个很普通的数组，而且可以通过append（）方法将新字符串加入value[]末尾，这样也就改变了value[]的内容和大小。

总结：讨论String和StringBuffer可不可变，本质上指对象中的value[]字符数组可不可变，而不是对象引用可不可变。

字符串String “+”连接符的原理

public class StringTest1 {
  public static void main(String[] args) {
    //代码1
    String s1 = "ab";
    String s2 = "cd";
    String str = s1 + s2 ;
    String ss = "abcd";
    System.out.println(str == ss);//false

    //代码2
    String st = "ab" + "cd";
    String sd = "abcd";
    System.out.println(st == sd);//true
  }
  
}

原因解释：

代码1中局部变量sa、sb中存储的是堆中常量两个拘留字符串对象的地址，当执行s1+s2时，JVM首先会在堆中创建一个StringBuilder类，同时用s1指向的拘留字符串对象完成初始化，然后调用append方法完成对sb指向的拘留字符串的合并操作，接着调用StringBuilder对象的toString（）方法在堆中创建一个String对象，最后将刚生成的String对象的堆地址存放在局部变量str中，而局部变量ss存放的是常量池中“abcd”所对应的拘留字符串对象的地址。所以str和ss的地址不一样。在这个过程中，实际上产生了五个字符串对象，三个拘留字符串对象、一个String对象、一个StringBuilder对象。

代码2中“ab” +“cd”会直接在编译器就合并成常量“abcd”，因此相同字面值常量“abcd”对应的是同一个对象，地址也会相同。

解释拘留字符串：

String s = "abcd",是一种非常特殊的形式，和new有本质的区别。它是Java中唯一不需要new就可以产生对象的途径。以String s = “abcd”形式赋值在Java中叫直接量，它是在常量池中而不是存放在压缩堆中。这样形式的字符串，在JVM内部发生字符串拘留，即当声明这样一个字符串后，JVM会在常量池中先查找有没有一个值为“abcd”的对象，如果有，就会把它赋值给当前引用。即原来那个引用和现在这个引用执向了同一个对象。如果没有，则在常量池中新创建一个“abcd”，即以这样形式声明的字符串，只要值相等，任何多个引用都指向同一对象。源代码中所有相同字面值的字符串常量只可能建立唯一一个拘留字符串对象。实际上JVM是通过一个记录了拘留字符串引用的内部数据结构来维持这一特性的。在Java中程序中，可以调用String的intern()方法来使得一个常规字符串对象成为拘留字符串对象。

String和StringBuffer累加的效率问题

先看下代码：

System.out.println("***********************************************");

     //1、字符串常量 +
     String ss = "";
     long start = System.currentTimeMillis();
     for (int i = 0; i < 10000; i++) {
      str = "Hello" + "Word";
     }
    long end = System.currentTimeMillis();
    System.out.println("字符串常量消耗时间：" + (end-start));


    //2、字符串常量 + 字符串变量
     String tt = "Hello";
     String aa = "Word";
     String bb = "";
    long st = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
      bb = tt + aa;
    }
    long dd = System.currentTimeMillis();
    System.out.println("字符串变量消耗时间：" + (dd-st));

    System.out.println("***********************************************");

    //3、字符串对象 累加
    String  x = "hello";
    String  y = "";
    long s = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
      y =  y + x;
    }
    long d = System.currentTimeMillis();
    System.out.println("字符串对象累加消耗时间：" + (d-s));


    //4、StringBuffer累加
    String x1 = "hello";
    StringBuffer y1 = new StringBuffer();
    long p = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
      y1.append(x1);
    }
    long e = System.currentTimeMillis();
    System.out.println("StringBuffer累加消耗时间：" + (e-p));

输出结果：