性能优化

一、避免在循环条件中使用复杂表达式
在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。 
例子： 

import java.util.vector;  class cel {      void method (vector vector) {          for (int i = 0; i < vector.size (); i++)  // violation              ; // ...      }  }  更正： [java] view plain copyclass cel_fixed {      void method (vector vector) {          int size = vector.size ()          for (int i = 0; i < size; i++)              ; // ...      }  }  

二、为'vectors' 和 'hashtables'定义初始大小 

jvm为vector扩充大小的时候需要重新创建一个更大的数组，将原原先数组中的内容复制过来，最后，原先的数组再被回收。可见vector容量的扩大是一个颇费时间的事。 
通常，默认的10个元素大小是不够的。你最好能准确的估计你所需要的最佳大小。 
例子： 

import java.util.vector;  public class dic {      public void addobjects (object[] o) {          // if length > 10, vector needs to expand          for (int i = 0; i< o.length;i++) {                  v.add(o);   // capacity before it can add more elements.          }      }      public vector v = new vector();  // no initialcapacity.  }  更正： 自己设定初始大小。 [java] view plain copypublic vector v = new vector(20);    public hashtable hash = new hashtable(10);  

三、在finally块中关闭stream 
程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。       
例子： 

import java.io.*;  public class cs {      public static void main (string args[]) {          cs cs = new cs ();          cs.method ();      }      public void method () {          try {              fileinputstream fis = new fileinputstream ("cs.java");              int count = 0;              while (fis.read () != -1)                  count++;              system.out.println (count);              fis.close ();          } catch (filenotfoundexception e1) {          } catch (ioexception e2) {          }      }  }         更正： 在最后一个catch后添加一个finally块 

四、使用'system.arraycopy ()'代替通过来循环复制数组 
'system.arraycopy ()' 要比通过循环来复制数组快的多。 
        
例子： 

public class irb  {      void method () {          int[] array1 = new int [100];          for (int i = 0; i < array1.length; i++) {              array1 [i] = i;          }          int[] array2 = new int [100];          for (int i = 0; i < array2.length; i++) {              array2 [i] = array1 [i];                 // violation          }      }  }        更正： public class irb  {      void method () {          int[] array1 = new int [100];          for (int i = 0; i < array1.length; i++) {              array1 [i] = i;          }          int[] array2 = new int [100];          system.arraycopy(array1, 0, array2, 0, 100);      }  }  

五、让访问实例内变量的getter/setter方法变成”final” 
简单的getter/setter方法应该被置成final，这会告诉编译器，这个方法不会被重载，所以，可以变成”inlined” 
例子： 

class maf {      public void setsize (int size) {           _size = size;      }      private int _size;  }  更正： [java] view plain copyclass daf_fixed {      final public void setsize (int size) {           _size = size;      }      private int _size;  }  

八、如果只是查找单个字符的话，用charat()代替startswith() 
用一个字符作为参数调用startswith()也会工作的很好，但从性能角度上来看，调用用string api无疑是错误的!      
例子： 

public class pcts {      private void method(string s) {          if (s.startswith("a")) { // violation              // ...          }      }  }           更正         将'startswith()' 替换成'charat()'. [java] view plain copypublic class pcts {      private void method(string s) {          if ('a' == s.charat(0)) {              // ...          }      }  }  

九、使用移位操作来代替'a / b'操作 
"/"是一个很“昂贵”的操作，使用移位操作将会更快更有效。 
例子： 

public class sdiv {      public static final int num = 16;      public void calculate(int a) {          int div = a / 4;            // should be replaced with "a >> 2".          int div2 = a / 8;         // should be replaced with "a >> 3".          int temp = a / 3;      }  }  更正： [java] view plain copypublic class sdiv {      public static final int num = 16;      public void calculate(int a) {          int div = a >> 2;            int div2 = a >> 3;          int temp = a / 3;       // 不能转换成位移操作      }  }  

十、使用移位操作代替'a * b' 
同上。 
[i]但我个人认为，除非是在一个非常大的循环内，性能非常重要，而且你很清楚你自己在做什么，方可使用这种方法。否则提高性能所带来的程序晚读性的降低将是不合算的。 

例子： 

public class smul {      public void calculate(int a) {          int mul = a * 4;            // should be replaced with "a << 2".          int mul2 = 8 * a;         // should be replaced with "a << 3".          int temp = a * 3;      }  }  更正： [java] view plain copypackage opt;  public class smul {      public void calculate(int a) {          int mul = a << 2;            int mul2 = a << 3;          int temp = a * 3;       // 不能转换      }  }  

十一、在字符串相加的时候，使用 ' ' 代替 " "，如果该字符串只有一个字符的话 

例子： 

public class str {      public void method(string s) {          string string = s + "d"  // violation.          string = "abc" + "d"      // violation.      }  }  更正： 将一个字符的字符串替换成' ' [java] view plain copypublic class str {      public void method(string s) {          string string = s + 'd'          string = "abc" + 'd'         }  }

十二、不要在循环中调用synchronized(同步)方法 
方法的同步需要消耗相当大的资料，在一个循环中调用它绝对不是一个好主意。 
例子： 

import java.util.vector;  public class syn {      public synchronized void method (object o) {      }      private void test () {          for (int i = 0; i < vector.size(); i++) {              method (vector.elementat(i));    // violation          }      }      private vector vector = new vector (5, 5);  }  更正： 不要在循环体中调用同步方法，如果必须同步的话，推荐以下方式： [java] view plain copyimport java.util.vector;  public class syn {      public void method (object o) {      }  private void test () {      synchronized{//在一个同步块中执行非同步方法              for (int i = 0; i < vector.size(); i++) {                  method (vector.elementat(i));                 }          }      }      private vector vector = new vector (5, 5);  }  

十三、将try/catch块移出循环 
把try/catch块放入循环体内，会极大的影响性能，如果编译jit被关闭或者你所使用的是一个不带jit的jvm，性能会将下降21%之多! 
         
例子：         

import java.io.fileinputstream;  public class try {      void method (fileinputstream fis) {          for (int i = 0; i < size; i++) {              try {                                      // violation                  _sum += fis.read();              } catch (exception e) {}          }      }      private int _sum;  }         更正：         将try/catch块移出循环           void method (fileinputstream fis) {         try {             for (int i = 0; i < size; i++) {                 _sum += fis.read();             }         } catch (exception e) {}     }  

十六、用'stringtokenizer' 代替 'indexof()' 和'substring()' 
字符串的分析在很多应用中都是常见的。使用indexof()和substring()来分析字符串容易导致 stringindexoutofboundsexception。而使用stringtokenizer类来分析字符串则会容易一些，效率也会高一些。 
例子： 

public class ust {      void parsestring(string string) {          int index = 0;          while ((index = string.indexof(".", index)) != -1) {              system.out.println (string.substring(index, string.length()));          }      }  }  

十七、使用条件操作符替代"if (cond) return; else return;" 结构 
条件操作符更加的简捷 
例子： 

public class if {      public int method(boolean isdone) {          if (isdone) {              return 0;          } else {              return 10;          }      }  }  更正： public class if {      public int method(boolean isdone) {          return (isdone ? 0 : 10);      }  }  

十八、使用条件操作符代替"if (cond) a = b; else a = c;" 结构 
例子： 

public class ifas {      void method(boolean istrue) {          if (istrue) {              _value = 0;          } else {              _value = 1;          }      }      private int _value = 0;  }  更正： public class ifas {      void method(boolean istrue) {          _value = (istrue ? 0 : 1);       // compact expression.      }      private int _value = 0;  }  

十九、不要在循环体中实例化变量 
在循环体中实例化临时变量将会增加内存消耗 
例子：         

import java.util.vector;  public class loop {      void method (vector v) {          for (int i=0;i < v.size();i++) {              object o = new object();              o = v.elementat(i);          }      }  }         更正：         在循环体外定义变量，并反复使用         import java.util.vector;  public class loop {      void method (vector v) {          object o;          for (int i=0;i<v.size();i++) {              o = v.elementat(i);          }      }  }  

二十、确定 stringbuffer的容量 
stringbuffer的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建stringbuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。 
例子：         

public class rsbc {      void method () {          stringbuffer buffer = new stringbuffer(); // violation          buffer.append ("hello");      }  }          更正：         为stringbuffer提供寝大小。         public class rsbc {      void method () {          stringbuffer buffer = new stringbuffer(max);          buffer.append ("hello");      }      private final int max = 100;  }  

二十二、不要总是使用取反操作符(!) 
取反操作符(!)降低程序的可读性，所以不要总是使用。 
例子： 

public class dun {      boolean method (boolean a, boolean b) {          if (!a)              return !a;          else              return !b;      }  }  

更正： 
如果可能不要使用取反操作符(!) 
10. 采用在需要的时候才开始创建的策略。 
例如： 

String str="abc";  if(i==1){ list.add(str);}  应修改为： if(i==1){String str="abc"; list.add(str);}  

17.不用new关键字创建对象的实例。 
用 new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用她的clone() 方法。clone()方法不会调用任何类构造函数。 
下面是Factory模式的一个典型实现。 

public static Credit getNewCredit()  {      return new Credit();  }  改进后的代码使用clone() 方法， private static Credit BaseCredit = new Credit();  public static Credit getNewCredit()  {      return (Credit)BaseCredit.clone();  }  

19.不要将数组声明为：public static final。 
20.HaspMap的遍历。 

Map<String, String[]> paraMap = new HashMap<String, String[]>();  for( Entry<String, String[]> entry : paraMap.entrySet() )  {      String appFieldDefId = entry.getKey();      String[] values = entry.getValue();  }  

利用散列值取出相应的Entry做比较得到结果，取得entry的值之后直接取key和 value。 
27.考虑使用静态方法， 
如果你没有必要去访问对象的外部，那么就使你的方法成为静态方法。她会被更快地调用，因为她不需要一个虚拟函数导向表。这同事也是一个很好的实践，因为她告诉你如何区分方法的性质，调用这个方法不会改变对象的状态。 

数值表达式 
1. 奇偶判断 
不要使用 i % 2 == 1 来判断是否是奇数，因为i为负奇数时不成立，请使用 i % 2 != 0 来判断是否是奇数，或使用 高效式 (i & 1) != 0来判断。 
2. 小数精确计算 

System.out.println(2.00 -1.10);//0.8999999999999999  

上面的计算出的结果不是 0.9，而是一连串的小数。问题在于1.1这个数字不能被精确表示为一个double，因此它被表 示为最接近它的double值，该程序从2中减去的就是这个值，但这个计算的结果并不是最接近0.9的double值。 
一般地说，问题在于并不是所有的小数都可以用二进制浮点数精确表示。 
二进制浮点对于货币计算是非常不适合的，因为它不可能将1.0表示成10的其他任何负次幂。 
解决问题的第一种方式是使用货币的最小单位（分）来表示： 

System.out.println(200-110);//90  

第二种方式是使用BigDecimal，但一定要用BigDecimal(String)构造器，而千万不要用 BigDecimal(double)来构造（也不能将float或double型转换成String再来使用BigDecimal(String)来构造，
因为在将float或double转换成String时精度已丢失）。 
例如new BigDecimal(0.1)， 
它将返回一个BigDecimal， 
也即0.1000000000000000055511151231257827021181583404541015625， 
正确使用BigDecimal，程序就可以打印出我们所期 望的结果0.9： 

System.out.println(new BigDecimal("2.0").subtract(new BigDecimal("1.10")));// 0.9  

另外，如果要比较两个浮点数的大小，要使用BigDecimal的compareTo方法。 
3. int整数相乘溢出 
我们计算一天中的微秒数： 
long microsPerDay = 24 * 60 * 60 * 1000 * 1000;// 正确结果应为：86400000000  
System.out.println(microsPerDay);// 实际上为：500654080  
  问题在于计算过程中溢出了。这个计算式完全是以int运算来执行的，并且只有在运算完成之后，其结果才被提升为long，而此时已经太迟：计算已经溢出。 
  解决方法使计算表达式的第一个因子明确为long型，这样可以强制表达式中所有的后续计算都用long运算来完成，这样结果就不会溢出： 
long microsPerDay = 24L * 60 * 60 * 1000 * 1000;