java基础——String、StringBuffer、StringBuilder

转载： https://blog.csdn.net/MAGIC_JSS/article/details/51367836

1.String：由多个字符组成的一串数据，相当与字符数组。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。字符串是常量，它们的值在创建之后不能更改。 
(1)字符串直接赋值和new String（…）的区别 
图解： 

2.StringBuffer:线程安全的可变字符序列。 
(1)StringBuffer与String的区别？

• StringBuffer的长度和内容可变，String不可变。
• StringBuffer做字符串的拼接会节约资源，更高效。

3.StringBuilder：一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。功能于StringBuffer相同。 
(1)StringBuffer与StringBuilder的区别？

• StringBuffer是同步的，线程安全，相对于StringBuilder效率低。
• StringBuilder是不同步的，线程不安全，效率高。 

1.String：

1）String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。在早期的JVM实现版本中，被final修饰的方法会被转为内嵌调用以提升执行效率。而从Java SE5/6开始，就渐渐摈弃这种方式了。因此在现在的Java SE版本中，不需要考虑用final去提升方法调用效率。只有在确定不想让该方法被覆盖时，才将方法设置为final。

2）String类其实是通过char数组来保存字符串的。

下面再看String类的一些方法实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 public String substring(int beginIndex, int endIndex) {     if (beginIndex < 0) {         throw new StringIndexOutOfBoundsException(beginIndex);     }     if (endIndex > count) {         throw new StringIndexOutOfBoundsException(endIndex);     }     if (beginIndex > endIndex) {         throw new StringIndexOutOfBoundsException(endIndex - beginIndex);     }     return ((beginIndex == 0) && (endIndex == count)) ? this :         new String(offset + beginIndex, endIndex - beginIndex, value);     }    public String concat(String str) {     int otherLen = str.length();     if (otherLen == 0) {         return this;     }     char buf[] = new char[count + otherLen];     getChars(0, count, buf, 0);     str.getChars(0, otherLen, buf, count);     return new String(0, count + otherLen, buf);     }    public String replace(char oldChar, char newChar) {     if (oldChar != newChar) {         int len = count;         int i = -1;         char[] val = value; /* avoid getfield opcode */         int off = offset;   /* avoid getfield opcode */           while (++i < len) {         if (val[off + i] == oldChar) {             break;         }         }         if (i < len) {         char buf[] = new char[len];         for (int j = 0 ; j < i ; j++) {             buf[j] = val[off+j];         }         while (i < len) {             char c = val[off + i];             buf[i] = (c == oldChar) ? newChar : c;             i++;         }         return new String(0, len, buf);         }     }     return this;

从上面的三个方法可以看出，无论是sub操、concat还是replace操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，最原始的字符串并没有被改变。

在这里要永远记住一点：

“对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象”。

在了解了于String类基础的知识后，下面来看一些在平常使用中容易忽略和混淆的地方。

2.String、StringBuffer以及StringBuilder的区别

既然在Java中已经存在了String类，那为什么还需要StringBuilder和StringBuffer类呢？

那么看下面这段代码：

1 2 3 4 5 6 7 8 9 public class Main {       public static void main(String[] args) {         String string = "";         for(int i=0;i<10000;i++){             string += "hello";         }     } }

这句 string += “hello”;的过程相当于将原有的string变量指向的对象内容取出与”hello”作字符串相加操作再存进另一个新的String对象当中，再让string变量指向新生成的对象。如果大家还有疑问可以反编译其字节码文件便清楚了：

从这段反编译出的字节码文件可以很清楚地看出：从第8行开始到第35行是整个循环的执行过程，并且每次循环会new出一个StringBuilder对象，然后进行append操作，最后通过toString方法返回String对象。也就是说这个循环执行完毕new出了10000个对象，试想一下，如果这些对象没有被回收，会造成多大的内存资源浪费。从上面还可以看出：string+=”hello”的操作事实上会自动被JVM优化成：

StringBuilder str = new StringBuilder(string);

str.append(“hello”);

str.toString();

再看下面这段代码：

1 2 3 4 5 6 7 8 9 public class Main {       public static void main(String[] args) {         StringBuilder stringBuilder = new StringBuilder();         for(int i=0;i<10000;i++){             stringBuilder.append("hello");         }     } }

反编译字节码文件得到：

从这里可以明显看出，这段代码的for循环式从13行开始到27行结束，并且new操作只进行了一次，也就是说只生成了一个对象，append操作是在原有对象的基础上进行的。因此在循环了10000次之后，这段代码所占的资源要比上面小得多。

那么有人会问既然有了StringBuilder类，为什么还需要StringBuffer类？查看源代码便一目了然，事实上，StringBuilder和StringBuffer类拥有的成员属性以及成员方法基本相同，区别是StringBuffer类的成员方法前面多了一个关键字：synchronized，不用多说，这个关键字是在多线程访问时起到安全保护作用的,也就是说StringBuffer是线程安全的。

下面摘了2段代码分别来自StringBuffer和StringBuilder，insert方法的具体实现：

StringBuilder的insert方法

1 2 3 4 5 6 public StringBuilder insert(int index, char str[], int offset,                               int len)   {       super.insert(index, str, offset, len);   return this;   }

StringBuffer的insert方法：

1 2 3 4 5 6 public synchronized StringBuffer insert(int index, char str[], int offset,                                             int len)     {         super.insert(index, str, offset, len);         return this;     }

常见的关于String、StringBuffer的面试题

下面是一些常见的关于String、StringBuffer的一些面试笔试题，若有不正之处，请谅解和批评指正。

1. 下面这段代码的输出结果是什么？

String a = “hello2″; 　　String b = “hello” + 2; 　　System.out.println((a == b));

输出结果为：true。原因很简单，”hello”+2在编译期间就已经被优化成”hello2″，因此在运行期间，变量a和变量b指向的是同一个对象。

2.下面这段代码的输出结果是什么？

String a = “hello2″; 　  String b = “hello”;       String c = b + 2;       System.out.println((a == c));

输出结果为:false。由于有符号引用的存在，所以  String c = b + 2;不会在编译期间被优化，不会把b+2当做字面常量来处理的，因此这种方式生成的对象事实上是保存在堆上的。因此a和c指向的并不是同一个对象。javap -c得到的内容：

3.下面这段代码的输出结果是什么？

String a = “hello2″;   　 final String b = “hello”;       String c = b + 2;       System.out.println((a == c));

输出结果为：true。对于被final修饰的变量，会在class文件常量池中保存一个副本，也就是说不会通过连接而进行访问，对final变量的访问在编译期间都会直接被替代为真实的值。那么String c = b + 2;在编译期间就会被优化成：String c = “hello” + 2; 下图是javap -c的内容：

4.下面这段代码输出结果为：

1 2 3 4 5 6 7 8 9 10 11 12 public class Main {     public static void main(String[] args) {         String a = "hello2";         final String b = getHello();         String c = b + 2;         System.out.println((a == c));     }       public static String getHello() {         return "hello";     } }

输出结果为false。这里面虽然将b用final修饰了，但是由于其赋值是通过方法调用返回的，那么它的值只能在运行期间确定，因此a和c指向的不是同一个对象。

5.下面这段代码的输出结果是什么？

1 2 3 4 5 6 7 8 9 10 11 12 13 public class Main {     public static void main(String[] args) {         String a = "hello";         String b =  new String("hello");         String c =  new String("hello");         String d = b.intern();           System.out.println(a==b);         System.out.println(b==c);         System.out.println(b==d);         System.out.println(a==d);     } }

输出结果为（JDK版本 JDK6)：

这里面涉及到的是String.intern方法的使用。在String类中，intern方法是一个本地方法，在JAVA SE6之前，intern方法会在运行时常量池中查找是否存在内容相同的字符串，如果存在则返回指向该字符串的引用，如果不存在，则会将该字符串入池，并返回一个指向该字符串的引用。因此，a和d指向的是同一个对象。

6.String str = new String(“abc”)创建了多少个对象？

这个问题在很多书籍上都有说到比如《Java程序员面试宝典》，包括很多国内大公司笔试面试题都会遇到，大部分网上流传的以及一些面试书籍上都说是2个对象，这种说法是片面的。

如果有不懂得地方可以参考这篇帖子：

http://rednaxelafx.iteye.com/blog/774673/

首先必须弄清楚创建对象的含义，创建是什么时候创建的？这段代码在运行期间会创建2个对象么？毫无疑问不可能，用javap -c反编译即可得到JVM执行的字节码内容：

很显然，new只调用了一次，也就是说只创建了一个对象。

而这道题目让人混淆的地方就是这里，这段代码在运行期间确实只创建了一个对象，即在堆上创建了”abc”对象。而为什么大家都在说是2个对象呢，这里面要澄清一个概念  该段代码执行过程和类的加载过程是有区别的。在类加载的过程中，确实在运行时常量池中创建了一个”abc”对象，而在代码执行过程中确实只创建了一个String对象。

因此，这个问题如果换成 String str = new String(“abc”)涉及到几个String对象？合理的解释是2个。

个人觉得在面试的时候如果遇到这个问题，可以向面试官询问清楚”是这段代码执行过程中创建了多少个对象还是涉及到多少个对象“再根据具体的来进行回答。

7.下面这段代码1）和2）的区别是什么？

1 2 3 4 5 6 7 8 public class Main {     public static void main(String[] args) {         String str1 = "I";         //str1 += "love"+"java";        1)         str1 = str1+"love"+"java";      //2)       } }

1）的效率比2）的效率要高，1）中的”love”+”java”在编译期间会被优化成”lovejava”，而2）中的不会被优化。下面是两种方式的字节码：

在1）中只进行了一次append操作，而在2）中进行了两次append操作。

参考文章：http://rednaxelafx.iteye.com/blog/774673/

http://www.blogjava.net/Jack2007/archive/2008/06/17/208602.html

http://www.jb51.net/article/36041.htm

http://blog.csdn.net/yirentianran/article/details/2871417

http://www.jb51.net/article/33398.htm

http://www.importnew.com/18167.html