phpprint992技巧_阿里架构师之Java 代码机能优化

代码优化也是一样，如果项目着眼于尽快无BUG上线，那么此时可以抓大放小，代码的细节可以不精打细磨；但是如果有足够的韶光开拓、掩护代码，这时候就必须考虑每个可以优化的细节了，一个一个眇小的优化点累积起来，对付代码的运行效率绝对是有提升的。

1、只管即便指定类、方法的final润色符

带有final润色符的类是不可派生的。
在Java核心API中，有许多运用final的例子，例如java.lang.String，全体类都是final的。
为类指定final润色符可以让类不可以被继续，为方法指定final润色符可以让方法不可以被重写。
如果指定了一个类为final，则该类所有的方法都是final的。
Java编译器会探求机会内联所有的final方法，内联对付提升Java运行效率浸染重大，详细拜会Java运行期优化。
此举能够使性能均匀提高50%。

2、只管即便重用工具

特殊是String工具的利用，涌现字符串连接时该当利用StringBuilder/StringBuffer代替。
由于Java虚拟机不仅要花韶光天生工具，往后可能还须要花韶光对这些工具进行垃圾回收和处理，因此，天生过多的工具将会给程序的性能带来很大的影响。

3、尽可能利用局部变量

调用方法时通报的参数以及在调用中创建的临时变量都保存在栈中速率较快，其他变量，如静态变量、实例变量等，都在堆中创建，速率较慢。
其余，栈中创建的变量，随着方法的运行结束，这些内容就没了，不须要额外的垃圾回收。

4、及时关闭流

Java编程过程中，进行数据库连接、I/O流操作时务必小心，在利用完毕后，及时关闭以开释资源。
由于对这些大工具的操作会造成系统大的开销，稍有不慎，将会导致严重的后果。

5、只管即便减少对变量的重复打算

明确一个观点，对方法的调用，纵然方法中只有一句语句，也是有花费的，包括创建栈帧、调用方法时保护现场、调用方法完毕时规复现场等。
以是例如下面的操作：

for(int i =0; i < list.size(); i++){...}

建议更换为：

for(int i =0, int length = list.size(); i < length; i++){...}

这样，在list.size()很大的时候，就减少了很多的花费

6、只管即便采取

例如：

Stringstr=\公众aaa\公众;if(i ==1){list.add(str);}

建议更换为：

if(i ==1){Stringstr=\"大众aaa\"大众;list.add(str);}

7、慎用非常

非常对性能不利。
抛出非常首先要创建一个新的工具，Throwable接口的布局函数调用名为fillInStackTrace()确当地同步方法，fillInStackTrace()方法检讨堆栈，网络调用跟踪信息。
只要有非常被抛出，Java虚拟机就必须调度调用堆栈，由于在处理过程中创建了一个新的工具。
非常只能用于缺点处理，不应该用来掌握程序流程。

8、不要在循环中利用try…catch…，该当把其放在最外层

除非不得已。
如果毫无情由地这么写了，只要你的领导资深一点、有强制症一点，八造诣要骂你为什么写出这种垃圾代码来了。

9、如果能估计到待添加的内容长度，为底层以数组办法实现的凑集、工具类指定初始长度

比如ArrayList、LinkedLlist、StringBuilder、StringBuffer、HashMap、HashSet等等，以StringBuilder为例：

（1）StringBuilder() // 默认分配16个字符的空间（2）StringBuilder(int size) // 默认分配size个字符的空间（3）StringBuilder(String str)　// 默认分配16个字符+str.length()个字符空间

可以通过类（这里指的不仅仅是上面的StringBuilder）的来设定它的初始化容量，这样可以明显地提升性能。
比如StringBuilder吧，length表示当前的StringBuilder能保持的字符数量。
由于当StringBuilder达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，无论何时只要StringBuilder达到它的最大容量，它就不得不创建一个新的字符数组然后将旧的字符数组内容拷贝到新字符数组中—-这是十分耗费性能的一个操作。
试想，如果能预估到字符数组中大概要存放5000个字符而不指定长度，最靠近5000的2次幂是4096，每次扩容加的2不管，那么：

（1）在4096 的根本上，再申请8194个大小的字符数组，加起来相称于一次申请了12290个大小的字符数组，如果一开始能指定5000个大小的字符数组，就节省了一倍以上的空间；

（2）把原来的4096个字符拷贝到新的的字符数组中去。

这样，既摧残浪费蹂躏内存空间又降落代码运行效率。
以是，给底层以数组实现的凑集、工具类设置一个合理的初始化容量是错不了的，这会带来吹糠见米的效果。
但是，把稳，像HashMap这种因此数组+链表实现的凑集，别把初始大小和你估计的大小设置得一样，由于一个table上只连接一个工具的可能性险些为0。
初始大小建议设置为2的N次幂，如果能估计到有2000个元素，设置成new HashMap(128)、new HashMap(256)都可以。

10、当复制大量数据时，利用System.arraycopy()命令

11、乘法和除法利用移位操作

例如：

for(val=0;val<100000;val+=5){a =val8;b =val/2;}

用移位操作可以极大地提高性能，由于在打算机底层，对位的操作是最方便、最快的，因此建议修正为：

for(val=0;val<100000;val+=5){a =val<<3;b =val>>1;}

移位操作虽然快，但是可能会使代码不太好理解，因此最好加上相应的注释。

12、循环内不要不断创建工具引用

例如：

for(inti =1; i <= count; i++){Objectobj =newObject();}

这种做法会导致内存中有count份Object工具引用存在，count很大的话，就耗费内存了，建议为改为：

Objectobj =null;for(inti =0; i <= count; i++) { obj =newObject(); }

这样的话，内存中只有一份Object工具引用，每次new Object()的时候，Object工具引用指向不同的Object罢了，但是内存中只有一份，这样就大大节省了内存空间了。

13、基于效率和类型检讨的考虑，该当尽可能利用array，无法确定数组大小时才利用ArrayList

14、只管即便利用HashMap、ArrayList、StringBuilder，除非线程安全须要，否则不推举利用Hashtable、Vector、StringBuffer，后三者由于利用同步机制而导致了性能开销

15、不要将数组声明为public static final

由于这毫无意义，这样只是定义了引用为static final，数组的内容还是可以随意改变的，将数组声明为public更是一个安全漏洞，这意味着这个数组可以被外部类所改变。

16、只管即便在得当的场合利用单例

利用单例可以减轻加载的包袱、缩短加载的韶光、提高加载的效率，但并不是所有地方都适用于单例，大略来说，单例紧张适用于以下三个方面：

（1）掌握资源的利用，通过线程同步来掌握资源的并发访问

（2）掌握实例的产生，以达到节约资源的目的

（3）掌握数据的共享，在不建立直接关联的条件下，让多个不干系的进程或线程之间实现通信

17、只管即便避免随意利用静态变量

要知道，当某个工具被定义为static的变量所引用，那么gc常日是不会回收这个工具所霸占的堆内存的，如：

publicclassA{privatestaticB b =newB();}

此时静态变量b的生命周期与A类相同，如果A类不被卸载，那么引用B指向的B工具会常驻内存，直到程序终止

18、及时打消不再须要的会话

为了打消不再活动的会话，许多运用做事器都有默认的会话超时时间，一样平常为30分钟。
当运用做事器须要保存更多的会话时，如果内存不敷，那么操作系统会把部分数据转移到磁盘，运用做事器也可能根据MRU（最近最频繁利用）算法把部分不生动的会话转储到磁盘，乃至可能抛出内存不敷的非常。
如果会话要被转储到磁盘，那么必须要先被序列化，在大规模集群中，对工具进行序列化的代价是很昂贵的。
因此，当会话不再须要时，应该及时调用HttpSession的invalidate()方法打消会话。

19、实现RandomAccess接口的凑集比如ArrayList，应该利用最普通的for循环而不是foreach循环来遍历

这是JDK推举给用户的。
JDK API对付RandomAccess接口的阐明是：实现RandomAccess接口用来表明其支持快速随机访问，此接口的紧张目的是许可一样平常的算法变动其行为，从而将其运用到随机或连续访问列表时能供应良好的性能。
实际履历表明，实现RandomAccess接口的类实例，如果是随机访问的，利用普通for循环效率将高于利用foreach循环；反过来，如果是顺序访问的，则利用Iterator会效率更高。
可以利用类似如下的代码作判断：

if(listinstanceofRandomAccess){for(int i =0; i iterator =list.iterable();while(iterator.hasNext()){iterator.next()}}

foreach循环的底层实现事理便是迭代器Iterator，拜会Java语法糖1：可变长度参数以及foreach循环事理。
所往后半句”反过来，如果是顺序访问的，则利用Iterator会效率更高”的意思便是顺序访问的那些类实例，利用foreach循环去遍历。

20、利用同步代码块替代同步方法

这点在多线程模块中的synchronized锁方法块一文中已经讲得很清楚了，除非能确定一全体方法都是须要进行同步的，否则只管即便利用同步代码块，避免对那些不须要进行同步的代码也进行了同步，影响了代码实行效率。

21、将常量声明为static final，并以大写命名

这样在编译期间就可以把这些内容放入常量池中，避免运行期间打算天生常量的值。
其余，将常量的名字以大写命名也可以方便区分出常量与变量

22、不要创建一些不该用的工具，不要导入一些不该用的类

这毫无意义，如果代码中涌现”The value of the local variable i is not used”、”The import java.util is never used”，那么请删除这些无用的内容

23、程序运行过程中避免利用反射

关于，请拜会反射。
反射是Java供应给用户一个很强大的功能，功能强大每每意味着效率不高。
不建议在程序运行过程中利用尤其是频繁利用反射机制，特殊是Method的invoke方法，如果确实有必要，一种建议性的做法是将那些须要通过反射加载的类在项目启动的时候通过反射实例化出一个工具并放入内存—-用户只关心和对端交互的时候获取最快的相应速率，并不关心对真个项目启动花多久韶光。

24、利用数据库连接池和线程池

这两个池都是用于重用工具的，前者可以避免频繁地打开和关闭连接，后者可以避免频繁地创建和销毁线程

25、利用带缓冲的输入输出流进行IO操作

带缓冲的输入输出流，即BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream，这可以极大地提升IO效率

26、顺序插入和随机访问比较多的场景利用ArrayList，元素删除和中间插入比较多的场景利用LinkedList

这个，理解ArrayList和LinkedList的事理就知道了

27、不要让public方法中有太多的形参

public方法即对外供应的方法，如果给这些方法太多形参的话紧张有两点坏处：

1、违反了面向工具的编程思想，Java讲求统统都是工具，太多的形参，和面向工具的编程思想并不契合

2、参数太多势必导致方法调用的出错概率增加

至于这个”太多”指的是多少个，3、4个吧。
比如我们用JDBC写一个insertStudentInfo方法，有10个学生信息字段要插如Student表中，可以把这10个参数封装在一个实体类中，作为insert方法的形参。

28、字符串变量和字符串常量equals的时候将字符串常量写在前面

这是一个比较常见的小技巧了，如果有以下代码：

String str =\"大众123\公众;if(str.equals(\公众123\"大众)) {...}

建议修正为：

String str =\"大众123\"大众;if(\"大众123\"大众.equals(str)){...}

这么做紧张是可以避免空指针非常

29、请知道，在java中if (i == 1)和if (1 == i)是没有差异的，但从阅读习气上讲，建议利用前者

平时有人问，”if (i == 1)”和”if (1== i)”有没有差异，这就要从C/C++讲起。

在C/C++中，”if (i == 1)”判断条件成立，因此0与非0为基准的，0表示false，非0表示true，如果有这么一段代码：

int i =2;if(i ==1){...}else{...}

C/C++判断”i==1″不成立，以是以0表示，即false。
但是如果：

int i =2;if(i =1) {...}else{...}

万一程序员一个欠妥心，把”if (i == 1)”写成”if (i = 1)”，这样就有问题了。
在if之内将i赋值为1，if判断里面的内容非0，返回的便是true了，但是明明i为2，比较的值是1，该当返回的false。
这种情形在C/C++的开拓中是很可能发生的并且会导致一些难以理解的缺点产生，以是，为了避免开拓者在if语句中禁绝确的赋值操作，建议将if语句写为：

int i =2;if(1== i) {...}else{...}

这样，纵然开拓者欠妥心写成了”1 = i”，C/C++编译器也可以第一韶光检讨出来，由于我们可以对一个变量赋值i为1，但是不能对一个常量赋值1为i。

但是，在Java中，C/C++这种”if (i = 1)”的语法是不可能涌现的，由于一旦写了这种语法，Java就会编译报错”Type mismatch: cannot convert from int to boolean”。
但是，只管Java的”if (i == 1)”和”if (1 == i)”在语义上没有任何差异，但是从阅读习气上讲，建议利用前者会更好些。

30、不要对数组利用toString()方法

看一下对数组利用toString()打印出来的是什么：

public static void main(String[] args){int[]is=newint[]{1,2,3};System.out.println(is.toString());}

结果是：

[I@18a992f

本意是想打印出数组内容，却有可能由于数组引用is为空而导致空指针非常。
不过虽然对数组toString()没故意义，但是对凑集toString()是可以打印出凑集里面的内容的，由于凑集的父类AbstractCollections重写了Object的toString()方法。

31、不要对超出范围的基本数据类型做向下逼迫转型

这绝不会得到想要的结果：

public static void main(String[] args){long l =12345678901234L;int i = (int) l;System.out.println(i);}

我们可能期望得到个中的某几位，但是结果却是：

1942892530

阐明一下。
Java中long是8个字节64位的，以是12345678901234在打算机中的表示该当是：

0000 0000 0000 0000 0000 1011 0011 1010 0111 0011 1100 1110 0010 1111 1111 0010

一个int型数据是4个字节32位的，从低位取出上面这串二进制数据的前32位是：

0111 0011 1100 1110 0010 1111 1111 0010

这串二进制表示为十进制1942892530，以是便是我们上面的掌握台上输出的内容。
从这个例子上还能顺便得到两个结论：

1、整型默认的数据类型是int，long l = 12345678901234L，这个数字已经超出了int的范围了，以是末了有一个L，表示这是一个long型数。
顺便，浮点型的默认类型是double，以是定义float的时候要写成””float f = 3.5f”

2、接下来再写一句”int ii = l + i;”会报错，由于long + int是一个long，不能赋值给int

32、公用的凑集类中不该用的数据一定要及时remove掉

如果一个凑集类是公用的（也便是说不是方法里面的属性），那么这个凑集里面的元素是不会自动开释的，由于始终有引用指向它们。
以是，如果公用凑集里面的某些数据不该用而不去remove掉它们，那么将会造成这个公用凑集不断增大，使得系统有内存透露的隐患。

33、把一个基本数据类型转为字符串，基本数据类型.toString()是最快的办法、String.valueOf(数据)次之、数据+””最慢

把一个基本数据类型转为一样平常有三种办法，我有一个Integer型数据i，可以利用i.toString()、String.valueOf(i)、i+””三种办法，三种办法的效率如何，看一个测试：

public static void main(String[] args){int loopTime =50000;Integer i =0;long startTime = System.currentTimeMillis();for(intj =0; j < loopTime; j++){String str = String.valueOf(i);}System.out.println(\"大众String.valueOf()：\"大众+ (System.currentTimeMillis() - startTime) +\"大众ms\"大众);startTime = System.currentTimeMillis();for(intj =0; j < loopTime; j++){String str = i.toString();}System.out.println(\"大众Integer.toString()：\公众+ (System.currentTimeMillis() - startTime) +\"大众ms\公众);startTime = System.currentTimeMillis();for(intj =0; j < loopTime; j++){String str = i +\公众\公众;}System.out.println(\"大众i + \\"大众\\公众：\"大众+ (System.currentTimeMillis() - startTime) +\公众ms\"大众);}

运行结果为：

String.valueOf()：11ms Integer.toString()：5ms i +\"大众\"大众：25ms

以是往后碰着把一个基本数据类型转为String的时候，优先考虑利用toString()方法。
至于为什么，很大略：

1、String.valueOf()方法底层调用了Integer.toString()方法，但是会在调用前做空判断

2、Integer.toString()方法就不说了，直接调用了

3、i + “”底层利用了StringBuilder实现，先用append方法拼接，再用toString()方法获取字符串

三者比拟下来，明显是2最快、1次之、3最慢

34、利用最有效率的办法去遍历Map

遍历Map的办法有很多，常日场景下我们须要的是遍历Map中的Key和Value，那么推举利用的、效率最高的办法是：

public static void main(String[] args){HashMap hm =newHashMap();hm.put(\公众111\"大众,\"大众222\"大众);Set<Map.Entry<String, String>> entrySet = hm.entrySet(); Iterator<Map.Entry<String, String>> iter = entrySet.iterator(); while (iter.hasNext()) { Map.Entry<String, String> entry = iter.next(); System.out.println(entry.getKey() + \"大众\t\"大众 + entry.getValue()); }}

如果你只是想遍历一下这个Map的key值，那用”Set keySet = hm.keySet();”会比较得当一些

35、对资源的close()建议分开操作

意思是，比如我有这么一段代码：

try{XXX.close();YYY.close();}catch (Exception e){...}

建议修正为：

try{ XXX.close(); }catch (Exception e) {...}try{ YYY.close(); }catch (Exception e) {...}

虽然有些麻烦，却能避免资源透露。
我想，如果没有修正过的代码，万一XXX.close()抛非常了，那么就进入了cath块中了，YYY.close()不会实行，YYY这块资源就不会回收了，一贯占用着，这样的代码一多，是可能引起资源句柄透露的。
而改为上面的写法之后，就担保了无论如何XXX和YYY都会被close掉。