java中String 、 StringBuilder 和 StringBuffer的联系与区别

  String作为java中最基本的类,担负着承载字符信息的作用。String具有不可变的final属性 , 这也决定了它对于在程序中传递信息的不可或缺性 。开发中,我们常常要对字符串进行拼接,这时我们会用到String对象重载的“+”操作符或concat(str)方法,也可以用StringBuilder、StringBuffer对象的append(str)方法来实现。

那么,String、StringBuilder、StringBuffer之间到底有什么联系和区别?

什么情况下分别适合使用这三个不同的类?

使用中需要注意哪些问题呢?

一 、String

1 . String对象是不可变的 :String是个final类,所以它不可以被继承,它的值是不可改变的

2 . Sting对象不同的创建方式的区别:

  .class字节码文件在被JVM加载时,常量(符号引用、字符串字面量等)会在方法区的常量池中存放。其中,源码中出现过的字符串字面常量会保存在CONSTANT_STRING_INFO常量表中,根据不同创建方式,会有不同的内容分配

  1)字面常量方式创建的String变量   

1 String str1 = "abcd";
2 String str2 = "abcd";
3 System.out.println(str1==str2);//true

可见上面创建的两个String的引用str1和str2都指向了CONSTANT_STRING_INFO常量表中的(同一个拘留字符串)同一地址值,所以str1==str2返回true。这是因为该类在加载时,字符串常量被存放在CONSTANT_STRING_INFO常量表中,并且同一字面值的字符串常量只会保存一次(称为拘留字符串)。注意:这里并没有创建String对象,因为没有在堆中分配内存。

2)通过new关键字创建String对象

1 String str1 = new String("string");
2 String str2 = new String("string");
3 System.out.println(str1==str2);//false

此时,str1==str2返回false。首先,字节码在加载时,将“string”字符串常量存放到CONSTANT_STRING_INFO常量表中,所以上面语句中出现的“String”被放在常量表的同一位置;然后,在执行上面两条语句是,通过关键字new,分别在堆中创建了两个对象,并且两对象在堆中保存的值均为“string”;也就是说,内存中共有三处存有同一字符串值:常量表中的拘留字符串、str1指向的堆空间、str2指向的堆空间。

3)通过intern()方法创建的String“对象”

1 String str1 = new String("string");
2 String str2 = new String("string").intern();
3 System.out.pringln(str1==str2);//true

intern()方法的作用:1.当常量池中的字符串常量表中存在与“string”拘留字符串内容相同的字符串时,则直接返回这个拘留字符串地址值,赋值给str2,此时并没有创建新的对象;2.当常量池中的字符创常量表中没有“string”拘留字符串时,则把“string”添加到常量池并保存到字符串常量表中,成为拘留字符串,然后在堆中创建String对象并将对象的引用返回,此时有新的对象创建。此方法主要是为了避免重复创建字符串对象。

3 . String中重载 + 操作符的原理

我们都知道,在String重载的+操作符前后可以拼接其他内容,包括基本数据类型和引用数据类型,并且其他数据类型都会转化成String类型。

其实,重载+操作符实际上,都是创建了一个StringBuilder或StringBuffer对象,用append方法对字符串进行拼接,最后调用toString方法返回字符串。

需要注意 + 拼接字符串的两种情况 :

1 String str1 = "str";
2 String str2 = "ing";
3 String str = str1 + str2;
4 String str1_2 = "string";
5 System.out.pringln(str == str1_2);//false

这里 + 拼接的str1、str2是两个字符串变量,所以首先创建StringBuilder/StringBuffer对象,append(str1).append(str2)把str1和str2拼接起来,最后通过toString()生成一个新的String对象并把引用返回,赋值给str。这里创建了新的对象,所以会返回false;

1 String str1 = "str" + "ing";
2 String str2 = "string";
3 System.out.pringln(str1 == str2);//true

使用 + 操作符拼接两个字符串字面量时,JVM会自动将这两部分字符串合并成完整的字符串常量值,保存到常量池的字符串常量表中成为拘留字符串。所以,这里只是将拘留字符串返回了而已,并没有创建新的对象。

4 . String类的concat(str)方法拼接字符串

只能将String类型的内容拼接到调用者后面,并不能像重载的+ 操作符那样拼接其他数据类型的内容。

 1 public String concat(String str) {      
 2   int otherLen = str.length();      
 3   if (otherLen == 0) {          
 4     return this;  
 5     }  
 6     char buf[] = new char[count + otherLen];  
 7     getChars(0, count, buf, 0);  
 8     str.getChars(0, otherLen, buf, count);  
 9     return new String(0, count + otherLen, buf);  
10}  

可以看到,concat(str)方法拼接字符串的原理是创建一个新的char[]字符数组,把两个字符串转化成char类型之后存放到数组中,最后用char[]数组创建一个新的String对象。

二 、StringBuilder

1 . StringBuilder是一个非线程安全的final类,不能被继承

2 . append(str)方法的原理

 1 public StringBuilder append(String str) {
 2     super.append(str);
 3     return this;
 4 }

调用了父类的append(str)方法:

 1   public AbstractStringBuilder append(String str) {
 2         if (str == null) {
 3             str = "null";
 4         }
 5         int len = str.length();
 6         if (len == 0) {
 7             return this;
 8         }
 9 
10         int newCount = count + len;//统计拼接后字符串长度
11         if (newCount > value.length) {
12             expandCapacity(newCount);//如果拼接结果大于所用的char[],则扩容
13         }
14        //getChars将拼接字符串赋值到char[]中
15         str.getChars(0, len, value, count);
16         count = newCount;//更新char[]所保存的字符串长度
17         return this;
18     }

可知,用StringBuilder拼接字符串时,其实是在底层创建了一个char[]数组,然后通过char[]把要拼接的字符串添加到char[]而已。最后通过toString()生成最终拼接结果时就是通过  return new String(char[]) 实现的。

三 、StringBuffer

1 . StringBuffer是线程安全的final类,不能被继承

2 . append(str)方法

1 public synchronized StringBuffer append(String str) {
2     super.append(str);
3     return this;
4 }

可以看到,StringBuffer的append也是调用父类AbstractStringBuilder的append方法实现的,原理同StringBuilder。其唯一不同的地方在于,加了一个syncrhoized关键字修饰append()方法,保证了线程同步。

四 、String、StringBuilder和StringBuffer性能比较与选用

1 . 性能:StringBuilder > StringBuffer > String

  从上面四种(其实应该说是五种,+ 分为字符串常量的拼接和变量的拼接两种)的字符串拼接来看,除了字符串常量的拼接是返回拘留字符串的地址外,其他四种(str1+str2str1.concat(str2)、builder.append(str1).append(str2)buffer.append(str1).append(str2)都是使用了StringBuilder,或者说是StringBuilder的父类的拼接方法来做的——创建一个char数组,把需要拼接的内容先存进char数组,最后通过char数组创建新的String对象返回。

            造成三者性能差别的主要原因是:

  用String的 + 累加拼接字符串变量时,每拼接一个就会创建一个StringBuilder,并通过append()方法拼接,然后返回一个新的String对象。然后再继续拼接下一个变量。这样就会导致重复创建StringBuilder对象,性能低下。用 concat() 累计拼接时,则每两个字符串拼接都会创建一个 char[] 进行内容拼接并返回一个新的String对象作为结果,重复调用concat()会导致重复创建char[]和新String对象,性能低下。

  StringBuilder在调用toString()之前都不会创建拼接结果,并且底层的char数组会自动扩容,一直到拼接字符串全部存入char数组后,调用toString()时才创建新的String对象并返回,这样就避免了重复创建,效率提高。

              StringBuffer则因为使用了syncrhoized对append()进行了加锁,所以导致性能稍微低于StringBuilder。

2 . 不同情境下的选用

拼接两个字符串字面量,用 + 操作符;

单线程下拼接两个字符串变量,用StringBuilder;  

多线程下拼接两个字符串变量,用StringBuffer 。

猜你喜欢

转载自www.cnblogs.com/dingm/p/10505691.html
0条评论
添加一条新回复