可供程序利用的资源（内存、CPU韶光、网络带宽等）是有限的，优化的目的便是让程序用尽可能少的资源完成预定的任务。优化常日包含两方面的内容：减小代码的体积，提高代码的运行效率。本文谈论的紧张是如何提高代码的效率。
在Java程序中，性能问题的大部分缘故原由并不在于Java措辞，而是在于程序本身。养成好的代码编写习气非常主要，比如精确地、奥妙地利用java.lang.String类和java.util.Vector类，它能够显著地提高程序的性能。下面我们就来详细地剖析一下这方面的问题。
1、 只管即便指定类的final润色符带有final润色符的类是不可派生的。在Java核心API中，有许多运用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。其余，如果指定一个类为final，则该类所有的方法都是final。Java编译器会探求机会内联（inline）所有的final方法（这和详细的编译器实现有关）。此举能够使性能均匀提高50% 。
2、 只管即便重用工具。特殊是String 工具的利用中，涌现字符串连接情形时运用StringBuffer 代替。由于系统不仅要花韶光天生工具，往后可能还需花韶光对这些工具进行垃圾回收和处理。因此，天生过多的工具将会给程序的性能带来很大的影响。
3、 只管即便利用局部变量，调用方法时通报的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速率较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速率较慢。其余，依赖于详细的编译器/JVM，局部变量还可能得到进一步优化。请拜会《尽可能利用堆栈变量》。
4、 不要重复初始化变量 默认情形下，调用类的布局函数时， Java会把变量初始化成确定的值：所有的工具被设置成null，整数变量（byte、short、int、long）设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其该当把稳，由于用new关键词创建一个工具时，布局函数链中的所有布局函数都会被自动调用。
5、 在JAVA + ORACLE 的运用系统开拓中，java中内嵌的SQL语句只管即便利用大写的形式，以减轻ORACLE解析器的解析包袱。
6、 Java 编程过程中，进行数据库连接、I/O流操作时务必小心，在利用完毕后，纵然关闭以开释资源。由于对这些大工具的操作会造成系统大的开销，稍有不慎，会导致严重的后果。
7、 由于JVM的有其自身的GC机制，不须要程序开拓者的过多考虑，从一定程度上减轻了开拓者包袱，但同时也遗漏了隐患，过分的创建工具会花费系统的大量内存，严重时会导致内存透露，因此，担保过期工具的及时回收具有主要意义。JVM回收垃圾的条件是：工具不在被引用；然而，JVM的GC并非十分的机警，纵然工具知足了垃圾回收的条件也不一定会被立即回收。以是，建议我们在工具利用完毕，应手动置成null。
8、 在利用同步机制时，应只管即便利用方法同步代替代码块同步。
9、 只管即便减少对变量的重复打算
例如：for(int i = 0;i < list.size; i ++) {
…
}
应更换为：
for(int i = 0,int len = list.size();i < len; i ++) {
…
}
10、只管即便采取lazy loading 的策略，即在须要的时候才开始创建。
例如： String str = “aaa”;
if(i == 1) {
list.add(str);
}
应更换为：
if(i == 1) {
String str = “aaa”;
list.add(str);
}
11、慎用非常
非常对性能不利。抛出非常首先要创建一个新的工具。Throwable接口的布局函数调用名为fillInStackTrace()确当地（Native）方法，fillInStackTrace()方法检讨堆栈，网络调用跟踪信息。只要有非常被抛出，VM就必须调度调用堆栈，由于在处理过程中创建了一个新的工具。非常只能用于缺点处理，不应该用来掌握程序流程。
12、不要在循环中利用：
Try {
} catch() {
}
应把其放置在最外层。
13、StringBuffer 的利用：
StringBuffer表示了可变的、可写的字符串。
有三个布局方法 :
StringBuffer (); //默认分配16个字符的空间
StringBuffer (int size); //分配size个字符的空间
StringBuffer (String str); //分配16个字符+str.length()个字符空间
你可以通过StringBuffer的布局函数来设定它的初始化容量，这样可以明显地提升性能。这里提到的布局函数是StringBuffer(int length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以利用ensureCapacity(int minimumcapacity)方法在StringBuffer工具创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找出一条更好的提升性能的路子。
StringBuffer在内部掩护一个字符数组，当你利用缺省的布局函数来创建StringBuffer工具的时候，由于没有设置初始化字符长度，StringBuffer的容量被初始化为16个字符，也便是说缺省容量便是16个字符。当StringBuffer达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，也便是（2旧值+2）。如果你利用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到34（216+2），当追加到34个字符的时候就会将容量增加到70（234+2）。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。以是总是给StringBuffer设置一个合理的初始化容量值是错不了的，这样会带来吹糠见米的性能增益。
StringBuffer初始化过程的调度的浸染由此可见一斑。以是，利用一个得当的容量值来初始化StringBuffer永久都是一个最佳的建议。
14、合理的利用Java类 java.util.Vector。
大略地说，一个Vector便是一个java.lang.Object实例的数组。Vector与数组相似，它的元素可以通过整数形式的索引访问。但是，Vector类型的工具在创建之后，工具的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子：
Object obj = new Object();
Vector v = new Vector(100000);
for(int I=0;
I<100000; I++) { v.add(0,obj); }
除非有绝对充足的情由哀求每次都把新元素插入到Vector的前面，否则上面的代码对性能不利。在默认布局函数中，Vector的初始存储能力是10个元素，如果新元素加入时存储能力不敷，则往后存储能力每次更加。Vector类就象StringBuffer类一样，每次扩展存储能力时，所有现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级：
Object obj = new Object();
Vector v = new Vector(100000);
for(int I=0; I<100000; I++) { v.add(obj); }
同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”，删除除末了一个元素之外的任意其他元素都导致被删除元素之后的元素向前移动。也便是说，从Vector删除末了一个元素要比删除第一个元素“开销”低好几倍。
假设要从前面的Vector删除所有元素，我们可以利用这种代码：
for(int I=0; I<100000; I++)
{
v.remove(0);
}
但是，与下面的代码比较，前面的代码要慢几个数量级：
for(int I=0; I<100000; I++)
{
v.remove(v.size()-1);
}
从Vector类型的工具v删除所有元素的最好方法是：
v.removeAllElements();
假设Vector类型的工具v包含字符串“Hello”。考虑下面的代码，它要从这个Vector中删除“Hello”字符串：
String s = \公众Hello\公众;
int i = v.indexOf(s);
if(I != -1) v.remove(s);
这些代码看起来没什么缺点，但它同样对性能不利。在这段代码中，indexOf()方法对v进行顺序搜索探求字符串“Hello”，remove(s)方法也要进行同样的顺序搜索。改进之后的版本是：
String s = \公众Hello\公众;
int i = v.indexOf(s);
if(I != -1) v.remove(i);
这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置，从而避免了第二次搜索。一个更好的版本是：
String s = \"大众Hello\公众; v.remove(s);
末了，我们再来看一个有关Vector类的代码片段：
for(int I=0; I++;I < v.length)
如果v包含100,000个元素，这个代码片段将调用v.size()方法100,000次。虽然size方法是一个大略的方法，但它仍旧须要一次方法调用的开销，至少JVM须要为它配置以及打消堆栈环境。在这里，for循环内部的代码不会以任何办法修正Vector类型工具v的大小，因此上面的代码最好改写成下面这种形式：
int size = v.size(); for(int I=0; I++;I<size)
虽然这是一个大略的改动，但它仍旧赢得了性能。毕竟，每一个CPU周期都是宝贵的。
15、当复制大量数据时，利用System.arraycopy()命令。
16、代码重构：增强代码的可读性。
例如：
public class ShopCart {
private List carts ;
…
public void add (Object item) {
if(carts == null) {
carts = new ArrayList();
}
crts.add(item);
}
public void remove(Object item) {
if(carts. contains(item)) {
carts.remove(item);
}
}
public List getCarts() {
//返回只读列表
return Collections.unmodifiableList(carts);
}
//不推举这种办法
//this.getCarts().add(item);
}
17、不用new关键词创建类的实例
用new关键词创建类的实例时，布局函数链中的所有布局函数都会被自动调用。但如果一个工具实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类布局函数。
在利用设计模式（Design Pattern）的场合，如果用Factory模式创建工具，则改用clone()方法创建新的工具实例非常大略。例如，下面是Factory模式的一个范例实现：
public static Credit getNewCredit() {
return new Credit();
}
改进后的代码利用clone()方法，如下所示：
private static Credit BaseCredit = new Credit();
public static Credit getNewCredit() {
return (Credit) BaseCredit.clone();
}
上面的思路对付数组处理同样很有用。
18、乘法和除法
考虑下面的代码：
for (val = 0; val < 100000; val +=5) {
alterX = val 8; myResult = val 2;
}
用移位操作替代乘法操作可以极大地提高性能。下面是修正后的代码：
for (val = 0; val < 100000; val += 5) {
alterX = val << 3; myResult = val << 1;
}
修正后的代码不再做乘以8的操作，而是改用等价的左移3位操作，每左移1位相称于乘以2。相应地，右移1位操作相称于除以2。值得一提的是，虽然移位操作速率快，但可能使代码比较难于理解，以是最好加上一些注释。
19、在JSP页面中关闭无用的会话。
一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，把稳如果JSP没有显示的利用 <%@pagesession=\公众false\"大众%> 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session工具的来历。由于session会花费内存资源，因此，如果不打算利用session，该当在所有的JSP中关闭它。
对付那些无需跟踪会话状态的页面，关闭自动创建的会话可以节省一些资源。利用如下page指令：<%@ page session=\"大众false\"大众%>
20、JDBC与I/O
如果运用程序须要访问一个规模很大的数据集，则应该考虑利用块提取办法。默认情形下，JDBC每次提取32行数据。举例来说，假设我们要遍历一个5000行的记录集，JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512，则调用数据库的次数将减少到10次。
[p][/p]21、Servlet与内存利用
许多开拓者随意地把大量信息保存到用户会话之中。一些时候，保存在会话中的工具没有及时地被垃圾回收机制回收。从性能上看，范例的症状是用户感到系统周期性地变慢，却又不能把缘故原由归于任何一个详细的组件。如果监视JVM的堆空间，它的表现是内存占用不正常地大起大落。
办理这类内请安题紧张有二种办法。第一种办法是，在所有浸染范围为会话的Bean中实现HttpSessionBindingListener接口。这样，只要实现valueUnbound()方法，就可以显式地开释Bean利用的资源。其余一种办法便是尽快地把会话作废。大多数运用做事器都有设置会话作废间隔韶光的选项。其余，也可以用编程的办法调用会话的setMaxInactiveInterval()方法，该方法用来设定在作废会话之前，Servlet容器许可的客户要求的最大间隔韶光，以秒计。
22、利用缓冲标记
一些运用做事器加入了面向JSP的缓冲标记功能。例如，BEA的WebLogic Server从6.0版本开始支持这个功能，Open Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断，也能够缓冲全体页面。当JSP页面实行时，如果目标片断已经在缓冲之中，则天生该片断的代码就不用再实行。页面级缓冲捕获对指定URL的要求，并缓冲全体结果页面。对付购物篮、目录以及门户网站的主页来说，这个功能极其有用。对付这类运用，页面级缓冲能够保存页面实行的结果，供后继要求利用。
23、选择得当的引用机制
在范例的JSP运用系统中，页头、页脚部分每每被抽取出来，然后根据须要引入页头、页脚。当前，在JSP页面中引入外部资源的方法紧张有两种：include指令，以及include动作。
include指令：例如<%@ include file=\公众copyright.html\"大众 %>。该指令在编译时引入指定的资源。在编译之前，带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定，比运行时才确定资源更高效。
include动作：例如<jsp:include page=\公众copyright.jsp\"大众 />。该动作引入指定页面实行后天生的结果。由于它在运行时完成，因此对输出结果的掌握更加灵巧。但时，只有当被引用的内容频繁地改变时，或者在对主页面的要求没有涌现之前，被引用的页面无法确定时，利用include动作才合算。
24、及时打消不再须要的会话
为了打消不再活动的会话，许多运用做事器都有默认的会话超时时间，一样平常为30分钟。当运用做事器须要保存更多会话时，如果内存容量不敷，操作系统会把部分内存数据转移到磁盘，运用做事器也可能根据“最近最频繁利用”（Most Recently Used）算法把部分不生动的会话转储到磁盘，乃至可能抛出“内存不敷”非常。在大规模系统中，串行化会话的代价是很昂贵的。当会话不再须要时，应该及时调用HttpSession.invalidate()方法打消会话。HttpSession.invalidate()方法常日可以在运用的退出页面调用。
25、不要将数组声明为：public static final 。
26、HashMap的遍历效率谈论
常常碰着对HashMap中的key和value值对的遍历操作，有如下两种方法：Map<String, String[]> paraMap = new HashMap<String, String[]>();
................//第一个循环
Set<String> appFieldDefIds = paraMap.keySet();
for (String appFieldDefId : appFieldDefIds) {
String[] values = paraMap.get(appFieldDefId);
......
}
//第二个循环
for(Entry<String, String[]> entry : paraMap.entrySet()){
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
.......
}
第一种实现明显的效率不如第二种实现。
剖析如下 Set<String> appFieldDefIds = paraMap.keySet(); 是先从HashMap中取得keySet
代码如下：
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}
private class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}
实在便是返回一个私有类KeySet, 它是从AbstractSet继续而来，实现了Set接口。
再来看看for/in循环的语法
for(declaration : expression_r)
statement
在实行阶段被翻译成如下各式
for(Iterator<E> #i = (expression_r).iterator(); #i.hashNext();){
declaration = #i.next();
statement
}
因此在第一个for语句for (String appFieldDefId : appFieldDefIds) 中调用了HashMap.keySet().iterator() 而这个方法调用了newKeyIterator()
Iterator<K> newKeyIterator() {
return new KeyIterator();
}
private class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}
以是在for中还是调用了
在第二个循环for(Entry<String, String[]> entry : paraMap.entrySet())中利用的Iterator是如下的一个内部类
private class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
此时第一个循环得到key，第二个循环得到HashMap的Entry
效率便是从循环里面表示出来的第二个循环此致可以直接取key和value值
而第一个循环还是得再利用HashMap的get(Object key)来取value值
现在看看HashMap的get(Object key)方法
public V get(Object key) {
Object k = maskNull(key);
int hash = hash(k);
int i = indexFor(hash, table.length); //Entry[] table
Entry<K,V> e = table;
while (true) {
if (e == null)
return null;
if (e.hash == hash && eq(k, e.key))
return e.value;
e = e.next;
}
}
实在便是再次利用Hash值取出相应的Entry做比较得到结果，以是利用第一中循环相称于两次进入HashMap的Entry中
而第二个循环取得Entry的值之后直接取key和value，效率比第一个循环高。实在按照Map的观点来看也该当是用第二个循环好一点，它本来便是key和value的值对，将key和value分开操作在这里不是个好选择。
27、array(数组) 和 ArryList的利用
array（[]）：最高效；但是其容量固定且无法动态改变；
ArrayList：容量可动态增长；但捐躯效率；
基于效率和类型考验，应尽可能利用array，无法确定数组大小时才利用ArrayList！
ArrayList是Array的繁芜版本
ArrayList内部封装了一个Object类型的数组，从一样平常的意义来说，它和数组没有实质的差别，乃至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的根本上直接调用Array的对应方法。
ArrayList存入工具时，抛弃类型信息，所有工具屏蔽为Object，编译时不检讨类型，但是运行时会报错。
注：jdk5中加入了对泛型的支持，已经可以在利用ArrayList时进行类型检讨。
从这一点上看来，ArrayList与数组的差异紧张便是由于动态增容的效率问题了
28、只管即便利用HashMap 和ArrayList ,除非必要，否则不推举利用HashTable和Vector ，后者由于利用同步机制，而导致了性能的开销。
29、StringBuffer 和StringBuilder的差异：
java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修正。StringBuilder。与该类比较，常日该当优先利用 java.lang.StringBuilder类，由于它支持所有相同的操作，但由于它不实行同步，以是速率更快。为了得到更好的性能，在布局 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。当然，如果你操作的字符串长度不超过 16 个字符就不用了。 相同情形下利用 StirngBuilder 比较利用 StringBuffer 仅能得到 10%-15% 旁边的性能提升，但却要冒多线程不屈安的风险。而在现实的模块化编程中，卖力某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非你能确定你的系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，否则还是用 StringBuffer 吧。
