array1[i]=i;
}
int[]array2=newint[100];
System.arraycopy（array1,0,array2,0,100）;
}
}
参考资料：
http:
//www.cs.cmu.edu/~jch/java/speed.html
五、让访问实例内变量的getter/setter方法变成”final”
简单的getter/setter方法应该被置成final，这会告诉编译器，这个方法不会被重载，所以，可以变成”inlined”
例子：
classMAF{
publicvoidsetSize（intsize）{
_size=size;
}
privateint_size;
}
更正：
classDAF_fixed{
finalpublicvoidsetSize（intsize）{
_size=size;
}
privateint_size;
}
参考资料：
WarrenN.andBishopP.（1999）,"JavainPractice",p.4-5
Addison-Wesley,ISBN0-201-36065-9
六、避免不需要的instanceof操作
如果左边的对象的静态类型等于右边的，instanceof表达式返回永远为true。
例子：
publicclassUISO{
publicUISO（）{}
}
classDogextendsUISO{
voidmethod（Dogdog,UISOu）{
Dogd=dog;
if（dinstanceofUISO）//alwaystrue.
System.out.println（"DogisaUISO"）;
UISOuiso=u;
if（uisoinstanceofObject）//alwaystrue.
System.out.println（"uisoisanObject"）;
}
}
更正：
删掉不需要的instanceof操作。
classDogextendsUISO{
voidmethod（）{
Dogd;
System.out.println（"DogisanUISO"）;
System.out.println（"UISOisanUISO"）;
}
}
七、避免不需要的造型操作
所有的类都是直接或者间接继承自Object。
同样，所有的子类也都隐含的“等于”其父类。
那么，由子类造型至父类的操作就是不必要的了。
例子：
classUNC{
String_id="UNC";
}
classDogextendsUNC{
voidmethod（）{
Dogdog=newDog（）;
UNCanimal=（UNC）dog;//notnecessary.
Objecto=（Object）dog;//notnecessary.
}
}
更正：
classDogextendsUNC{
voidmethod（）{
Dogdog=newDog（）;
UNCanimal=dog;
Objecto=dog;
}
}
参考资料：
NigelWarren,PhilipBishop:
"JavainPractice-DesignStylesandIdioms
forEffectiveJava".Addison-Wesley,1999.pp.22-23
八、如果只是查找单个字符的话，用charAt（）代替startsWith（）
用一个字符作为参数调用startsWith（）也会工作的很好，但从性能角度上来看，调用用StringAPI无疑是错误的!
例子：
publicclassPCTS{
privatevoidmethod（Strings）{
if（s.startsWith（"a"））{//violation
//...
}
}
}
更正
将'startsWith（）'替换成'charAt（）'.
publicclassPCTS{
privatevoidmethod（Strings）{
if（'a'==s.charAt（0））{
//...
}
}
}
参考资料：
DovBulka,"JavaPerformanceandScalabilityVolume1:
Server-SideProgramming
Techniques"AddisonWesley,ISBN:
0-201-70429-3
九、使用移位操作来代替'a/b'操作
"/"是一个很“昂贵”的操作，使用移位操作将会更快更有效。
例子：
publicclassSDIV{
publicstaticfinalintNUM=16;
publicvoidcalculate（inta）{
intdiv=a/4;//shouldbereplacedwith"a>>2".
intdiv2=a/8;//shouldbereplacedwith"a>>3".
inttemp=a/3;
}
}
更正：
publicclassSDIV{
publicstaticfinalintNUM=16;
publicvoidcalculate（inta）{
intdiv=a>>2;
intdiv2=a>>3;
inttemp=a/3;//不能转换成位移操作
}
}
十、使用移位操作代替'a*b'
同上。
[i]但我个人认为，除非是在一个非常大的循环内，性能非常重要，而且你很清楚你自己在做什么，方可使用这种方法。
否则提高性能所带来的程序晚读性的降低将是不合算的。
例子：
publicclassSMUL{
publicvoidcalculate（inta）{
intmul=a*4;//shouldbereplacedwith"a<<2".
intmul2=8*a;//shouldbereplacedwith"a<<3".
inttemp=a*3;
}
}
更正：
packageOPT;
publicclassSMUL{
publicvoidcalculate（inta）{
intmul=a<<2;
intmul2=a<<3;
inttemp=a*3;//不能转换
}
}
十一、在字符串相加的时候，使用''代替""，如果该字符串只有一个字符的话
例子：
publicclassSTR{
publicvoidmethod（Strings）{
Stringstring=s+"d"//violation.
string="abc"+"d"//violation.
}
}
更正：
将一个字符的字符串替换成''
publicclassSTR{
publicvoidmethod（Strings）{
Stringstring=s+'d'
string="abc"+'d'
}
}
十二、不要在循环中调用synchronized（同步）方法
方法的同步需要消耗相当大的资料，在一个循环中调用它绝对不是一个好主意。
例子：
importjava.util.Vector;
publicclassSYN{
publicsynchronizedvoidmethod（Objecto）{
}
privatevoidtest（）{
for（inti=0;imethod（vector.elementAt（i））;//violation
}
}
privateVectorvector=newVector（5,5）;
}
更正：
不要在循环体中调用同步方法，如果必须同步的话，推荐以下方式：
importjava.util.Vector;
publicclassSYN{
publicvoidmethod（Objecto）{
}
privatevoidtest（）{
synchronized{//在一个同步块中执行非同步方法
for（inti=0;imethod（vector.elementAt（i））;
}
}
}
privateVectorvector=newVector（5,5）;
}
十三、将try/catch块移出循环
把try/catch块放入循环体内，会极大的影响性能，如果编译JIT被关闭或者你所使用的是一个不带JIT的JVM，性能会将下降21%之多!
例子：
importjava.io.FileInputStream;
publicclassTRY{
voidmethod（FileInputStreamfis）{
for（inti=0;itry{//violation
_sum+=fis.read（）;
}catch（Exceptione）{}
}
}
privateint_sum;
}
更正：
将try/catch块移出循环
voidmethod（FileInputStreamfis）{
try{
for（inti=0;i_sum+=fis.read（）;
}
}catch（Exceptione）{}
}
参考资料：
PeterHaggar:
"PracticalJava-ProgrammingLanguageGuide".
AddisonWesley,2000,pp.81–83
十四、对于boolean值，避免不必要的等式判断
将一个boolean值与一个true比较是一个恒等操作（直接返回该boolean变量的值）.移走对于boolean的不必要操作至少会带来2个好处：
1）代码执行的更快（生成的字节码少了5个字节）；
2）代码也会更加干净。
例子：
publicclassUEQ
{
booleanmethod（Stringstring）{
returnstring.endsWith（"a"）==true;//Violation
}
}
更正：
classUEQ_fixed
{
booleanmethod（Stringstring）{
returnstring.endsWith（"a"）;
}
}
十五、对于常量字符串，用'String'代替'StringBuffer'
常量字符串并不需要动态改变长度。
例子：
publicclassUSC{
Stringmethod（）{
StringBuffers=newStringBuffer（"Hello"）;
Stringt=s+"World!
";
returnt;
}
}
更正：
把StringBuffer换成String，如果确定这个String不会再变的话，这将会减少运行开销提高性能。
十六、用'StringTokenizer'代替'indexOf（）'和'substring（）'
字符串的分析在很多应用中都是常见的。
使用indexOf（）和substring（）来分析字符串容易导致StringIndexOutOfBoundsException。
而使用StringTokenizer类来分析字符串则会容易一些，效率也会高一些。
例子：
publicclassUST{
voidparseString（Stringstring）{
intindex=0;
while（（index=string.indexOf（".",index））!
=-1）{
System.out.println（string.substring（index,string.length（）））;
}
}
}
参考资料：
GraigLarman,RhettGuthrie:
"Java2PerformanceandIdiomGuide"
PrenticeHallPTR,ISBN:
0-13-014260-3pp.282–283
十七、使用条件操作符替代"if（cond）return;elsereturn;"结构
条件操作符更加的简捷
例子：
publicclassIF{
publicintmethod（booleanisDone）{
if（isDone）{
return0;
}else{
return10;
}
}
}
更正：
publicclassIF{
publicintmethod（booleanisDone）{
return（isDone?
0:
10）;
}
}
十八、使用条件操作符代替"if（cond）a=b;elsea=c;"结构
例子：
publicclassIFAS{
voidmethod（booleanisTrue）{
if（isTrue）{
_value=0;
}else{
_value=1;
}
}
privateint_value=0;
}
更正：
publicclassIFAS{
voidmethod（booleanisTrue）{
_value=（isTrue?
0:
1）;//compactexpression.
}
privateint_value=0;
}
十九、不要在循环体中实例化变量
在循环体中实例化临时变量将会增加内存消耗
例子：
importjava.util.Vector;
publicclassLOOP{
voidmethod（Vectorv）{
for（inti=0;iObjecto=newObject（）;
o=v.elementAt（i）;
}
}
}
更正：
在循环体外定义变量，并反复使用
importjava.util.Vector;
publicclassLOOP{
voidmethod（Vectorv）{
Objecto;
for（inti=0;io=v.elementAt（i）;
}
}
}
二十、确定StringBuffer的容量
StringBuffer的构造器会创建一个默认大小（通常是16）的字符数组。
在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。
在大多数情况下，你可以在创建StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。
例子：
publicclassRSBC{
voidmethod（）{
StringBufferbuffer=newStringBuffer（）;//violation
buffer.append（"hello"）;
}
}
更正：
为StringBuffer提供寝大小。
publicclassRSBC{
voidmethod（）{
StringBufferbuffer=newStringBuffer（MAX）;
buffer.append（"hello"）;
}
privatefinalintMAX=100;
}
参考资料：
DovBulka,"JavaPerformanceandScalabilityVolume1:
Server-SideProgramming
Techniques"AddisonWesley,ISBN:
0-201-70429-3p.30–31
二十一、尽可能的使用栈变量
如果一个变量需要经常访问，那么你就需要考虑这个变量的作用域了。
static?
local?
还是实例变量？
访问静态变量和实例变量将会比访问局部变量多耗费2-3个时钟周期。
例子：
publicclassUSV{
voidgetSum（int[]values）{
for（inti=0;i_sum+=value[i];//violation.
}
}
voidg
升级会员 