java性能优化1--字符串优化处理

1. String对象
   　　String对象是java中重要的数据类型，在大部分情况下我们都会用到String对象。其实在Java语言中，其设计者也对String做了大量的优化工作，这些也是String对象的特点，它们就是:不变性，常量池优化和String类的final定义。
   
   1.1 不变性
   　　String对象的状态在其被创建之后就不在发生变化。为什么说这点也是Java设计者所做的优化，在java模式中，有一种模式叫不变模式，了解的童鞋也应该知道不变模式的作用：在一个对象被多线程共享，而且被频繁的访问时，可以省略同步和锁的时间，从而提高性能。而String的不变性，可泛化为不变模式。
   
   1.2 常量池优化
   
   　　常量池优化指的是什么呢？那就是当两个String对象拥有同一个值的时候，他们都只是引用了常量池中的同一个拷贝。所以当程序中某个字符串频繁出现时，这个优化技术就可以节省大幅度的内存空间了。例如：
   
   

   1 String s1  = "123";
   2 String s2  = "123";
   3 String s3 = new String("123");
   4 System.out.println(s1==s2);      //true
   5 System.out.println(s1==s3);      //false
   6 System.out.println(s1==s3.intern());    //true

   　　以上代码中，s1和s2引用的是相同的地址，故而第四行打印出的结果是true;而s3虽然只与s1,s2相等，但是s3时通过new String("123")创建的，重新开辟了内存空间，因引用的地址不同，所以第5行打印出false;intern方法返回的是String对象在常亮池中的引用，所以最后一行打印出true。
   
   
   1.3 final的定义
   　　String类以final进行了修饰，在系统中就不可能有String的子类，这一点也是出于对系统安全性的考虑。

2. 字符串操作中的常见优化方法
   2.1 split()方法优化
   　　通常情况下，split()方法带给我们很大的方便，但是其性能不是很好。建议结合使用indexOf()和subString()方法进行自定义拆分，这样性能会有显著的提高。　　　　
   
   2.2 String常亮的累加操作优化方法
   　　示例代码:

    1 String s = "";
    2 long sBeginTime = System.currentTimeMillis();
    3 for (int i = 0; i < 100000; i++) {
    4     s+="s";
    5 }
    6 long sEndTime = System.currentTimeMillis();
    7 System.out.println("s拼接100000遍s耗时: " + (sEndTime - sBeginTime) + "ms");
    8         
    9 StringBuffer s1 = new StringBuffer();
   10 long s1BeginTime = System.currentTimeMillis();
   11 for (int i = 0; i < 100000; i++) {
   12     s1.append("s");
   13 }
   14 long s1EndTime = System.currentTimeMillis();
   15 System.out.println("s1拼接100000遍s耗时: " + (s1EndTime - s1BeginTime) + "ms");
   16         
   17 StringBuilder s2 = new StringBuilder();
   18 long s2BeginTime = System.currentTimeMillis();
   19 for (int i = 0; i < 100000; i++) {
   20     s2.append("s");
   21 }
   22 long s2EndTime = System.currentTimeMillis();
   23 System.out.println("s2拼接100000遍s耗时: " + (s2EndTime - s2BeginTime) + "ms");

   　　结果:
   
   　　

   　　上例所示，使用+号拼接字符串，其效率明显较低，而使用StringBuffer和StringBuilder的append()方法进行拼接，效率是使用+号拼接方式的百倍甚至千倍，而StringBuffer的效率比StringBuilder低些，这是由于StringBuffer实现了线程安全，效率较低也是不可避免的。所以在字符串的累加操作中，建议结合线程问题选择，应避免使用+号拼接字符串。
   
   2.3 StringBuffer和StringBuilder的选择
   　　上例中也使用过StringBuffer和StringBuilder了，两者只有线程安全方面的差别，所以呢，在无需考虑线程安全的情况下，建议使用性能相对较高的StringBuilder类，若系统要求线程安全，就选择StringBuffer类。
   
   2.4 基本数据类型转化为String类型的优化方案
   　　示例代码:
   　　

    1 Integer num  = 0;
    2 int loop = 100000;  // 将结果放大100000倍，以便于观察结果
    3 long beginTime = System.currentTimeMillis();
    4 for (int i = 0; i < loop; i++) {
    5     String s = num+"";
    6 }
    7 long endTime = System.currentTimeMillis();
    8 System.out.println("+\"\"的方式耗时: " + (endTime - beginTime) + "ms");
    9         
   10         
   11 beginTime = System.currentTimeMillis();
   12 for (int i = 0; i < loop; i++) {
   13     String s = String.valueOf(num);
   14 }
   15 endTime = System.currentTimeMillis();
   16 System.out.println("String.valueOf()的方式耗时: " + (endTime - beginTime) + "ms");
   17         
   18 beginTime = System.currentTimeMillis();
   19 for (int i = 0; i < loop; i++) {
   20     String s = num.toString();
   21 }
   22 endTime = System.currentTimeMillis();
   23 System.out.println("toString()的方式耗时: " + (endTime - beginTime) + "ms");

   　　以上示例中，String.valueOf()直接调用了底层的Integer.toString()方法，不过其中会先判空；+""由StringBuilder实现，先调用了append()方法，然后调用了toString()方法获取字符串；num.toString()直接调用了Integer.toString()方法，所以效率是:num.toString()方法最快，其次是String.valueOf(num)，最后是num+""的方式。以下是结果截图:
   　　

   　　建议童鞋们避免使用+""的方式转换，最好是使用基本数据类型自带的toString()方法转换。就先分享到这儿吧!!!