Java中的String不再纠结

1. String str1 = "string";
2. String str4 = "string";
3. String str2 = new String("string");
4. String str3 = new String("string");
6. /*用于测试两种创建字符串方式的区别*/
7. System.out.println(str1 == str4);
8. System.out.println(str2 == str3);
9. System.out.println(str3 == str1);
11. str3 = str3.intern(); //一个不常见的方法
12. System.out.println(str3 == str1);

这个的运行结果是 true //解释：两个字符串的内容完全相同，因而指向常量池中的同一个区域 false //解释：每一次new都会创建一个新的对象 false // 解释： 注意==比较的是地址，不仅仅是内容 true //介绍一下intern方法，这个方法会返回一个字符串在常量池中的一个地址，如果常量池中有与str3内容相同的string则返回那个地址，如果没有，则在常量池中创建一个string后再返回。实际上，str3现在指向了str1的地址。 这就是让人纠结的string了，现在你可以说话了。。。很多人有这样的疑问就是既然string是不变的，那么为什么str1 + "some"是合法的，其实，每次对string进行修改，都会创建一个新的对象。 所以如果需要对一个字符串不断的修改的话，效率是非常的低的，因为堆的好处是可以动态的增加空间，劣势就是分配新的空间消耗是很大的，比如我们看下面的测试。

1. long start = System.currentTimeMillis();
3. for(int i = 0; i < 50000; i++)
4. {
5. str1+= " ";
6. }
8. long end = System.currentTimeMillis();
9. System.out.println("the run time is "+(end -start)+" ms");

我的机器上运行结果是the run time is 3538 ms 如果你把循环的次数后面再增加几个0就会更慢。因为每一次循环都在创建心的对象，那么JDK如何解决这个问题？ 下面就要说第二个类StringBuffer。 StringBuffer是一个线程安全的，就是多线程访问的可靠保证，最重要的是他是可变的，也就是说我们要操作一个经常变化的字符串，可以使用这个类，基本的方法就是append（与string的concat方法对应）和insert方法，至于怎么使用，就不多讲了，大家可以自己查看API。

1. StringBuilder sb = new StringBuilder("string builder");
2. StringBuffer sf = new StringBuffer("string buffer");
4. long start = System.currentTimeMillis();
6. for(int i = 0; i < 50000; i++)
7. {
8. //str1+= " ";
9. sb.append(" ");
10. }
12. long end = System.currentTimeMillis();
13. System.out.println("the run time is "+(end -start)+" ms");

测试一下，这次只需要8ms，这就是效率。 那么接下来，就要问StringBuilder是干什么的，其实这个才是我们尝使用的，这个就是在jdk 1.5版本后面添加的新的类，前面说StringBuffer是线程同步的，那么很多情况下，我们只是使用一个线程，那个同步势必带来一个效率的问题，StringBuilder就是StringBuffer的非线程同步的版本，二者的方法差不多，只是一个线程安全（适用于多线程）一个没有线程安全（适用于单线程）。 其实看了一下jdk源代码就会发现，StringBuffer就是在各个方法上加上了关键字syncronized 以上就是对三个字符串类的一个总结，总之不要在这上面纠结。。。。。。不想介绍太多的方法，总觉得那样会把一篇博客弄成API文档一样，而且还非常的繁琐。都是些体会，希望有所帮助。起码不要再纠结，尤其是面试。。。。