java性能优化

•  尽可能使用堆栈变量

        如果您频繁存取变量，就需要考虑从何处存取这些变量。变量是 static 变量，
 还是堆栈变量，或者是类的实例变量？变量的存储位置对存取它的代码的性能有明
 显的影响？例如，请考虑下面这段代码：

class  StackVars
... {
  private int instVar;
  private static int staticVar;
  
  //存取堆栈变量
  void stackAccess(int val)
  ...{
    int j=0;
    for (int i=0; i<val; i++)
      j += 1;
  }
  
  //存取类的实例变量
  void instanceAccess(int val)
  ...{
    for (int i=0; i<val; i++)
      instVar += 1;
  }   
  
  //存取类的 static 变量
  void staticAccess(int val)
  ...{
    for (int i=0; i<val; i++)
      staticVar += 1;
  }
}      

    这段代码中的每个方法都执行相同的循环，并反复相同的次数。唯一的不同是每个循环
使一个不同类型的变量递增。方法 stackAccess 使一个局部堆栈变量递增，instanceAccess
使类的一个实例变量递增，而 staticAccess 使类的一个 static 变量递增。

    instanceAccess 和 staticAccess 的执行时间基本相同。但是，stackAccess 要快两到三倍。
存取堆栈变量如此快是因为，JVM 存取堆栈变量比它存取 static 变量或类的实例变量执行的
操作少。

    查看字节码揭示了堆栈变量效率更高的原因。JVM 是一种基于堆栈的虚拟机，因此优化了对堆
栈数据的存取和处理。所有局部变量都存储在一个局部变量表中，在 Java 操作数堆栈中进行
处理，并可被高效地存取。存取 static 变量和实例变量成本更高，因为 JVM 必须使用代价
更高的操作码，并从常数存储池中存取它们。（常数存储池保存一个类型所使用的所有类型、
字段和方法的符号引用。）

    通常，在第一次从常数存储池中访问 static 变量或实例变量以后，JVM 将动态更改字节码以
使用效率更高的操作码。尽管有这种优化，堆栈变量的存取仍然更快。

考虑到这些事实，就可以重新构建前面的代码，以便通过存取堆栈变量而不是实例变量或
static 变量使操作更高效。请考虑修改后的代码：

class  StackVars
... {
  //与前面相同...
  void instanceAccess(int val)
  ...{
    int j = instVar;
    for (int i=0; i<val; i++)
      j += 1;
    instVar = j;
  }  
  
  void staticAccess(int val)
  ...{
    int j = staticVar;
    for (int i=0; i<val; i++)
      j += 1;
    staticVar = j;
  }
}     

    方法 instanceAccess 和 staticAccess 被修改为将它们的实例变量或 static 变量复制到
局部堆栈变量中。当变量的处理完成以后，其值又被复制回实例变量或 static 变量中。这种
简单的更改明显提高了 instanceAccess 和 staticAccess 的性能。这三个方法的执行时间
现在基本相同，instanceAccess 和 staticAccess 的执行速度只比 stackAccess 的执行速度
慢大约 4%。
 /*======== 循环的最佳化 ========*/
把循环
 for (int i = 0; i < 100; i++)
 {}
改成
 for (int i = 99; i >= 0; i--)
 {}

后，速度会更快，之所以会有效的提升，是因为如果数值要与0比较，在底层都有较简单的指令可以对应，
也因此加速了程序的执行。其它(> >= < <= !=)都可以这样考虑

• String比StringBuffer节省内存，但StringBuffer运行速度比String快
  

package  com;

public   class  Test 
... {
 public static void main(String[] args) 
 ...{
  Runtime rt = Runtime.getRuntime();
  long start = rt.totalMemory() - rt.freeMemory();
  System.out.println("memory used start: " + start);  
  String sum = "";
  for (int i = 0; i < 5000; i++)
  ...{
   sum = sum + "+" + i;
  }
  long end = rt.totalMemory() - rt.freeMemory();
  System.out.println("memory used end: " + end);
  System.out.println("总共消耗了内存： " + (end - start));
 }
}

输出：
memory used start: 132280
memory used end: 189648
总共消耗了内存： 57368

package  com;

public   class  Test 
... {
 public static void main(String[] args) 
 ...{
  Runtime rt = Runtime.getRuntime();
  long start = rt.totalMemory() - rt.freeMemory();
  System.out.println("memory used start: " + start);  
  StringBuffer sum = new StringBuffer("");
  for (int i = 0; i < 5000; i++)
  ...{
   sum = sum.append("+").append(i);
  }
  long end = rt.totalMemory() - rt.freeMemory();
  System.out.println("memory used end: " + end);
  System.out.println("总共消耗了内存： " + (end - start));
 }
}

输出：
memory used start: 132192
memory used end: 281056
总共消耗了内存： 148864

    书上说使用StringBuffer比Sting更能节省内存，但从上面可以看出，好像StringBuffer消耗的内存多,

     经过测试，发现String比StringBuffer节省内存，但StringBuffer运行速度比String快。

•    不用new关键词创建类的实例

     对象的创建是个很昂贵的工作,所以我们应当尽量减少对象的创建,在需要的时候
 声明它,初始化它,不要重复初始化一个对象,尽量能做到再使用,而用完后置null有利于
 垃圾收集。让类实现Cloneable接口,同时采用工厂模式,将减少类的创建,每次都是通过
 clone()方法来获得对象。另外使用接口也能减少类的创建。对于成员变量的初始化也
 应尽量避免, 特别是在一个类派生另一个类时。

　　 异常抛出对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数
 调用名为, fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法检查堆栈，
 收集调用跟踪信息。只要有异常被抛出，JVM就必须调整调用堆栈，因为在处理过程中创建
 了一个新的对象。 异常只能用于错误处理，不应该用来控制程序流程。

　　此外, 建议关闭Debug输出,尽量少用串行化、同步操作和耗时昂贵的服务(如Date())。      

•        使用合适的类型

      当原始类型不能满足我们要求时,使用复杂类型。String和StringBuffer的区别自不必
 说了,是我们使用最多的类型,在涉及到字符运算时,强烈建议使用StringBuffer。在做
 String匹配时使用intern()代替equal()。

　　带有final修饰符的类是不可派生的, 如果指定一个类为final，则该类所有的方法都是final。

　　Java编译器会寻找机会内联所有的final方法,这将能够使性能平均提高50%。类的属性和方式
 使用final或者static修饰符也是有好处的。

　　 调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。
 所以尽量使用局部变量。

　　 ArrayList和Vector,HashMap和Hashtable是我们经常用到的类,前者不支持同步,
 后者支持同步,前者性能更好,大多数情况下选择前者。