Java循环与字符串代码优化...

　　在系统性能优化的时候循环和字符串处理一直是JAVA中非常值得注意的地方。从心态上我们一定不能把自己的眼界放在十次或者是百次循环的层次上，也不能把自己要处理的字符串当做是有十个二十个字符。每次遇到循环都要假定这个循环是上万次的，每次要处理的字符串的时候一定要告诉自己这个字符串将来有可能是很大的。不要等到数据量真的达到十万、百万的级别之后再采取处理，那样的话成本的消耗就太大了。本文将介绍关于Java代码中循环和字符串的优化方法，希望对读者有用。
　　关于循环
　　嵌套for循环中次数多的放在内侧，次数少的放在外侧。众所周知for循环需要定义一个循环变量来遍历每一个需要循环的对象，那么如果循环次数多的循环放在外侧那么无疑将会使得总体的变量增多，效率自然会降低。下面进行代码测试
　　public class Test{
　　public static void main (String [] args)
　　{
　　Long time2Before=System.nanoTime();
　　for (int i=0; i<10;i++ ){
　　for (int j=0; j<1000000;j++ ){
　　
　　}
　　}
　　Long time2After=System.nanoTime();
　　System.out.println("faster--->"+(time2After-time2Before));
　　
　　Long time1Before=System.nanoTime();
　　for (int i=0; i<1000000;i++ ){
　　for (int j=0; j<10;j++ ){
　　
　　}
　　}
　　Long time1After=System.nanoTime();
　　System.out.println("slower--->"+(time1After-time1Before));
　　}
　　}
　　
　　在循环中只做与循环相关的事情，一些不必要的循环不要放到循环当中去做。比如在遍历集合的时候没有必要将取得集合大小放在循环中去做，完全可以放在集合的外边。效果上没区别，性能上差距巨大。
　　import java.util.*;
　　public class Test1{
　　public static void main (String [] args)
　　{
　　List<String> list=new ArrayList<String>();
　　for(int i=0;i<1000000;i++){
　　list.add("luck"+i);
　　}
　　
　　Long time1Before=System.nanoTime();
　　for(int i=0;i<list.size();i++){
　　// System.out.println(list.get(i));
　　}
　　Long time1After=System.nanoTime();
　　System.out.println("use .size-->"+(time1After-time1Before));
　　
　　Long time2Before=System.nanoTime();
　　int n=list.size();
　　for(int i=0;i<n;i++){
　　// System.out.println(list.get(i));
　　}
　　Long time2After=System.nanoTime();
　　System.out.println("do not use .size-->"+(time2After-time2Before));
　　
　　}
　　}
　　关于字符串
　　消除字符串连接，在程序中优先考虑使用StringBuffer或者StringBuilder代替String。一个字符串相当于一个匿名的String对象，如果在程序中拼接两个字符串那么会在内存中定义三个字符串空间。而StringBuffer或者StringBuilder就不会这么做，而是在原来已有的StringBuffer或者StringBuilder对象中进行修改。测试代码如下
　　public class Test3{
　　public static void main (String [] args)
　　{
　　long time1Before=System.nanoTime();
　　String str="";
　　for(int i=0;i<10000;i++){
　　str+=i;
　　}
　　long time1After=System.nanoTime();
　　System.out.println("use String --->  "+(time1After-time1Before));
　　
　　long time2Before=System.nanoTime();
　　StringBuilder sbuilder=new StringBuilder();
　　for(int i=0;i<10000;i++){
　　sbuilder.append(i);
　　}
　　long time2After=System.nanoTime();
　　System.out.println("use StringBuilder--->  "+(time2After-time2Before));
　　
　　long time3Before=System.nanoTime();
　　StringBuffer stringBuffer=new StringBuffer();
　　for(int i=0;i<10000;i++){
　　stringBuffer.append(i);
　　}
　　long time3After=System.nanoTime();
　　System.out.println("use StringBuffer--->  "+(time3After-time3Before));
　　}
　　}
　　
　　需要说明的是在StringBuffer和StringBuilder之间如果需要考虑选其一的话原则很简单，前者是线程安全的后者是线程不安全的，换句话说后者比前者更快。综上所述如果单单从性能上考虑的话从高到低依次是：StringBuilder --> StringBuffer --> String。
　　循环和字符串是程序中最容易提升代码效率的地方，因为很多人在写程序的时候为了图一时方便将效率抛在脑后，当要处理的数据不大的时候无所谓，一旦程序要处理的数据增大那么性能的瓶颈也就出现了。所以就像文章开头所说的，要在写程序的时候就要考虑十万百万的数量级，不要等到性能瓶颈出现再去解决，因为代码重构或者说后期的优化成本要远远高于前期的开发成本，相信看过别人无注释而又冗长代码的童鞋深有体会。