30 个编程小技巧，提高代码性能

前言

以下是在日常工作中总结出的一些编码经验，还有一些提高程序运行效率的小技巧，让我们一起来写出更好的代码吧。

尽量减少对变量的重复计算

明确一个概念，对方法的调用，即使方法中只有一句语句，也是有消耗的，包括创建栈帧、调用方法时保护现场、调用方法完毕时恢复现场等。所以例如下面的操作：

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

{...}

建议替换为：

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

{...}

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

字符串拼接问题

循环体内不要使用"+"进行字符串拼接，而直接使用 StringBuilder 不断 append

虚拟机碰到"+"这个操作符对字符串进行拼接的时候，会 new 出一个 StringBuilder，然后调用 append 方法。

最后调用 toString()方法转换字符串赋值给 oriStr 对象，即循环多少次，就会 new 出多少个 StringBuilder()来，这对于内存是一种浪费。

指定类、方法用 final 修饰

带有 final 修饰符的类是不可派生的。在 Java 核心 API 中，有许多应用 final 的例子，例如 java.lang.String，整个类都是 final 的。

为类指定 final 修饰符可以让类不可以被继承，为方法指定 final 修饰符可以让方法不可以被重写。如果指定了一个类为 final，则该类所有的方法都是 final 的。

Java 编译器会寻找机会内联所有的 final 方法，内联对于提升 Java 运行效率作用重大，具体参见 Java 运行期优化。此举能够使性能平均提高 50%。

尽可能使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中，速度较快，其他变量，如静态变量、实例变量等，都在堆中创建，速度较慢。

另外，栈中创建的变量，随着方法的运行结束，这些内容就没了，不需要额外的垃圾回收。

及时关闭流

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

尽量采用懒加载的策略

借鉴这种思想，就是需要挣个对象时在去创建

例如：

String str = "aaa";

if (i == 1)

{

list.add(str);

}

建议替换为:

if (i == 1)

{

String str = "aaa";

list.add(str);

}

慎用异常

异常对性能不利。抛出异常首先要创建一个新的对象，Throwable 接口的构造函数调用名为 fillInStackTrace()的本地同步方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。

只要有异常被抛出，Java 虚拟机就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。

try/catch

不要在循环中使用 try…catch…，应该把其放在最外层

使用集合时指定大小

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

StringBuilder()      // 默认分配 16 个字符的空间

StringBuilder(int size)  // 默认分配 size 个字符的空间

StringBuilder(String str) // 默认分配 16 个字符+str.length()个字符空间

可以通过类（这里指的不仅仅是上面的 StringBuilder）的构造函数来设定它的初始化容量，这样可以明显地提升性能。比如 StringBuilder 吧，length 表示当前的 StringBuilder 能保持的字符数量。

因为当 StringBuilder 达到最大容量的时候，它会将自身容量增加到当前的 2 倍再加 2，无论何时只要 StringBuilder 达到它的最大容量，它就不得不创建一个新的字符数组然后将旧的字符数组内容拷贝到新字符数组中----这是十分耗费性能的一个操作。试想，如果能预估到字符数组中大概要存放 5000 个字符而不指定长度，最接近 5000 的 2 次幂是 4096，每次扩容加的 2 不管，那么：

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

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

这样，既浪费内存空间又降低代码运行效率。所以，给底层以数组实现的集合、工具类设置一个合理的初始化容量是错不了的，这会带来立竿见影的效果。 但是，注意，像 HashMap 这种是以数组+链表实现的集合，别把初始大小和你估计的大小设置得一样，因为一个 table 上只连接一个对象的可能性几乎为 0。初始大小建议设置为 2 的 N 次幂，如果能估计到有 2000 个元素，设置成 new HashMap(128)、new HashMap(256)都可以。

当复制大量数据时

使用 System.arraycopy()命令

乘法和除法使用移位操作

例如：

for (val = 0; val < 100000; val += 5)

{

a = val * 8;

b = val / 2;

}

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

for (val = 0; val < 100000; val += 5)

{

a = val << 3;

b = val >> 1;

}

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

循环内不要不断创建对象引用

例如：

for (int i = 1; i <= count; i++)

{

Object obj = new Object();

}

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

Object obj = null;

for (int i = 0; i <= count; i++)

{

obj = new Object();

}

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

数组不要声明为 public static final

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

尽量在合适的场合使用单例

使用单例可以减轻加载的负担、缩短加载的时间、提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：

控制资源的使用，通过线程同步来控制资源的并发访问

控制实例的产生，以达到节约资源的目的

控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信

尽量避免随意使用静态变量

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

public class A

{

private static B b = new B();

}

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

及时清除不再需要的会话

为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为 30 分钟。当应用服务器需要保存更多的会话时，如果内存不足，那么操作系统会把部分数据转移到磁盘，应用服务器也可能根据 MRU（最近最频繁使用）算法把部分不活跃的会话转储到磁盘，甚至可能抛出内存不足的异常。

如果会话要被转储到磁盘，那么必须要先被序列化，在大规模集群中，对对象进行序列化的代价是很昂贵的。因此，当会话不再需要时，应当及时调用 HttpSession 的 invalidate()方法清除会话。

for 和 foreach

实现 RandomAccess 接口的集合比如 ArrayList，应当使用最普通的 for 循环而不是 foreach 循环来遍历

这是 JDK 推荐给用户的。JDK API 对于 RandomAccess 接口的解释是：实现 RandomAccess 接口用来表明其支持快速随机访问，此接口的主要目的是允许一般的算法更改其行为，从而将其应用到随机或连续访问列表时能提供良好的性能。

实际经验表明，实现 RandomAccess 接口的类实例，假如是随机访问的，使用普通 for 循环效率将高于使用 foreach 循环；反过来，如果是顺序访问的，则使用 Iterator 会效率更高。可以使用类似如下的代码作判断：

if (list instanceof RandomAccess)

{

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

}

else

{

Iterator<?> iterator = list.iterable();

while (iterator.hasNext()){iterator.next()}

}

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

使用同步代码块替代同步方法

除非能确定一整个方法都是需要进行同步的，否则尽量使用同步代码块，避免对那些不需要进行同步的代码也进行了同步，影响了代码执行效率。

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

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

程序运行过程中避免使用反射

反射是 Java 提供给用户一个很强大的功能，功能强大往往意味着效率不高。

不建议在程序运行过程中使用尤其是频繁使用反射机制，特别是 Method 的 invoke 方法。

如果确实有必要，一种建议性的做法是将那些需要通过反射加载的类在项目启动的时候通过反射实例化出一个对象并放入内存----用户只关心和对端交互的时候获取最快的响应速度，并不关心对端的项目启动花多久时间。

使用数据库连接池和线程池

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

使用带缓冲的输入输出流进行 IO 操作

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

ArrayList 和 LinkedList

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

equals

字符串变量和字符串常量 equals 的时候将字符串常量写在前面，这么做主要是可以避免空指针异常

if ("abc".equals(str)) {

}

不要对数组使用 toString()方法

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

public static void main(String[] args)

{

int[] is = new int[]{1, 2, 3};

System.out.println(is.toString());

// 输出内容：[I@156643d4

}

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

公用的集合类中不使用的数据一定要及时 remove 掉

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

基本数据类型转为字符串效率

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

测试速度：

public static void main(String[] args)

{

int loopTime = 50000;

Integer i = 0;

long startTime = System.currentTimeMillis();

for (int j = 0; j < loopTime; j++)

{

String str = String.valueOf(i);

}

System.out.println("String.valueOf()：" + (System.currentTimeMillis() - startTime) + "ms");

startTime = System.currentTimeMillis();

for (int j = 0; j < loopTime; j++)

{

String str = i.toString();

}

System.out.println("Integer.toString()：" + (System.currentTimeMillis() - startTime) + "ms");

startTime = System.currentTimeMillis();

for (int j = 0; j < loopTime; j++)

{

String str = i + "";

}

System.out.println("i + \"\"：" + (System.currentTimeMillis() - startTime) + "ms");

}

运行结果为：

String.valueOf()：11ms

Integer.toString()：5ms

i + ""：25ms

原因：

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

Integer.toString()方法就不说了

i + ""底层使用了 StringBuilder 实现，先用 append 方法拼接，再用 toString()方法获取字符串

遍历 Map 效率最高的方式

遍历 Map 的方式有很多，通常场景下我们需要的是遍历 Map 中的 Key 和 Value，那么推荐使用的、效率最高的方式是：

public static void main(String[] args)

{

HashMap<String, String> hm = new HashMap<String, String>();

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();会比较合适一些

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

例如：

try

{

XXX.close();

YYY.close();

}

catch (Exception e)

{

...

}

建议修改为：

try

{

XXX.close();

}

catch (Exception e)

{

...

}

try

{

YYY.close();

}

catch (Exception e)

{

...

}

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

ThreadLocal 使用前或者使用后一定要先 remove

线程池技术做的是一个线程重用，这意味着代码运行过程中，一条线程使用完毕，并不会被销毁而是等待下一次的使用。我们看一下 Thread 类中，持有 ThreadLocal.ThreadLocalMap 的引用：

/* ThreadLocal values pertaining to this thread. This map is maintained

* by the ThreadLocal class. */

ThreadLocal.ThreadLocalMap threadLocals = null;

线程不销毁意味着上条线程 set 的 ThreadLocal.ThreadLocalMap 中的数据依然存在，那么在下一条线程重用这个 Thread 的时候，很可能 get 到的是上条线程 set 的数据而不是自己想要的内容。

这个问题非常隐晦，一旦出现这个原因导致的错误，没有相关经验或者没有扎实的基础非常难发现这个问题，因此在写代码的时候就要注意这一点，这将给你后续减少很多的工作量。

重写方法必须保留 @Override 注解

清楚地可以知道这个方法由父类继承而来

getObject()和 get0bject()方法，前者第四个字母是"O"，后者第四个子母是"0"，加了 @Override 注解可以马上判断是否重写成功

在抽象类中对方法签名进行修改，实现类会马上报出编译错误