WHY？
1\减小代码的体积
2\提高代码运行的效率
HOW?
| （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）尽量减少对变量的重复计算 | |
| 明确一个概念，对方法的调用，即使方法中只有一句语句，也是有消耗的，包括创建栈帧、调用方法时保护现场、调用方法完毕时恢复现场等 | |
| （6）尽量采用懒加载的策略，即在需要的时候才创建 | |
| （7）慎用异常 | |
| 异常对性能不利。抛出异常首先要创建一个新的对象，Throwable接口的构造函数调用名为fillInStackTrace()的本地同步方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，Java虚拟机就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。 | |
| （8）不要在循环中使用try...catch...，应该把其放在最外层 | |
| 根据网友们提出的意见，这一点我认为值得商榷 | |
| （9）如果能估计到待添加的内容长度，为底层以数组方式实现的集合、工具类指定初始长度 | |
| （10）当复制大量数据时，使用System.arraycopy()命令 | |
| （11）乘法和除法使用移位操作 | |
| （12）循环内不要不断创建对象引用 | |
|
|
| （13）基于效率和类型检查的考虑，应该尽可能使用array，无法确定数组大小时才使用ArrayList | |
| （14）尽量使用HashMap、ArrayList、StringBuilder，除非线程安全需要，否则不推荐使用Hashtable、Vector、StringBuffer，后三者由于使用同步机制而导致了性能开销 | |
| （15）不要将数组声明为public static final | |
| 因为这毫无意义，这样只是定义了引用为static final，数组的内容还是可以随意改变的，将数组声明为public更是一个安全漏洞，这意味着这个数组可以被外部类所改变 | |
| （16）尽量在合适的场合使用单例 | |
| 使用单例可以减轻加载的负担、缩短加载的时间、提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：
|
|
| （17）尽量避免随意使用静态变量 | |
| 要知道，当某个对象被定义为static的变量所引用，那么gc通常是不会回收这个对象所占有的堆内存的， | |
| （18）及时清除不再需要的会话 | |
| 为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多的会话时，如果内存不足，那么操作系统会把部分数据转移到磁盘，应用服务器也可能根据MRU（最近最频繁使用）算法把部分不活跃的会话转储到磁盘，甚至可能抛出内存不足的异常。如果会话要被转储到磁盘，那么必须要先被序列化，在大规模集群中，对对象进行序列化的代价是很昂贵的。因此，当会话不再需要时，应当及时调用HttpSession的invalidate()方法清除会话。 | |
| （19）实现RandomAccess接口的集合比如ArrayList，应当使用最普通的for循环而不是foreach循环来遍历 | |
| 这是JDK推荐给用户的。JDK API对于RandomAccess接口的解释是：实现RandomAccess接口用来表明其支持快速随机访问，此接口的主要目的是允许一般的算法更改其行为，从而将其应用到随机或连续访问列表时能提供良好的性能。实际经验表明，实现RandomAccess接口的类实例，假如是随机访问的，使用普通for循环效率将高于使用foreach循环；反过来，如果是顺序访问的，则使用Iterator会效率更高。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方法即对外提供的方法，如果给这些方法太多形参的话主要有两点坏处：
至于这个"太多"指的是多少个，3、4个吧。比如我们用JDBC写一个insertStudentInfo方法，有10个学生信息字段要插如Student表中，可以把这10个参数封装在一个实体类中，作为insert方法的形参 |
|
| （28）字符串变量和字符串常量equals的时候将字符串常量写在前面 | |
| 这么做主要是可以避免空指针异常 | |
| （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， |
|
| （30）不要对数组使用toString()方法 | |
| （31）不要对超出范围的基本数据类型做向下强制转型 | |
| （32）公用的集合类中不使用的数据一定要及时remove掉 | |
| 如果一个集合类是公用的（也就是说不是方法里面的属性），那么这个集合里面的元素是不会自动释放的，因为始终有引用指向它们。所以，如果公用集合里面的某些数据不使用而不去remove掉它们，那么将会造成这个公用集合不断增大，使得系统有内存泄露的隐患。 | |
| （33）把一个基本数据类型转为字符串，基本数据类型.toString()是最快的方式、String.valueOf(数据)次之、数据+""最慢 |
|
| 把一个基本数据类型转为一般有三种方式，我有一个Integer型数据i，可以使用i.toString()、String.valueOf(i)、i+""三种方式，三种方式的效率如何 以后遇到把一个基本数据类型转为String的时候，优先考虑使用toString()方法。至于为什么，很简单：
三者对比下来，明显是2最快、1次之、3最慢 |
|
| （34）使用最有效率的方式去遍历Map | |
| 遍历Map的方式有很多，通常场景下我们需要的是遍历Map中的Key和Value | |
| （35）对资源的close()建议分开操作 | |
| 虽然有些麻烦，却能避免资源泄露。我们想，如果没有修改过的代码，万一XXX.close()抛异常了，那么就进入了catch块中了，YYY.close()不会执行，YYY这块资源就不会回收了，一直占用着，这样的代码一多，是可能引起资源句柄泄露的。而改为下面的写法之后，就保证了无论如何XXX和YYY都会被close掉 | |
| （36）对于ThreadLocal使用前或者使用后一定要先remove | |
| 当前基本所有的项目都使用了线程池技术，这非常好，可以动态配置线程数、可以重用线程。 然而，如果你在项目中使用到了ThreadLocal，一定要记得使用前或者使用后remove一下。这是因为上面提到了线程池技术做的是一个线程重用，这意味着代码运行过程中，一条线程使用完毕，并不会被销毁而是等待下一次的使用。 |
|
| （37）切记以常量定义的方式替代魔鬼数字，魔鬼数字的存在将极大地降低代码可读性，字符串常量是否使用常量定义可以视情况而定 | |
| （38）long或者Long初始赋值时，使用大写的L而不是小写的l，因为字母l极易与数字1混淆，这个点非常细节，值得注意 |
|
| （39）所有重写的方法必须保留@Override注解 | |
| 这么做有三个原因： （1）清楚地可以知道这个方法由父类继承而来 （2）getObject()和get0bject()方法，前者第四个字母是"O"，后者第四个子母是"0"，加了@Override注解可以马上判断是否重写成功 （3）在抽象类中对方法签名进行修改，实现类会马上报出编译错误 |
|
| （40）推荐使用JDK7中新引入的Objects工具类来进行对象的equals比较，直接a.equals(b)，有空指针异常的风险 |
|
| （41）循环体内不要使用"+"进行字符串拼接，而直接使用StringBuilder不断append | |
| （42）不捕获Java类库中定义的继承自RuntimeException的运行时异常类 | |
| 异常处理效率低，RuntimeException的运行时异常类，其中绝大多数完全可以由程序员来规避，比如：
|
|
| （43）避免Random实例被多线程使用，虽然共享该实例是线程安全的，但会因竞争同一seed 导致的性能下降，JDK7之后，可以使用ThreadLocalRandom来获取随机数 | |
| （44）静态类、单例类、工厂类将它们的构造函数置为private | |
| 这是因为静态类、单例类、工厂类这种类本来我们就不需要外部将它们new出来，将构造函数置为private之后，保证了这些类不会产生实例对象。 | |
编程规范
| 1优先返回空集合而非null |
| 如果程序要返回一个不包含任何值的集合，确保返回的是空集合而不是null。这能节省大量的”if else”检查。 public class getLocationName { return (null==cityName ? "": cityName); } |
| 2.谨慎操作字符串 |
| 如果两个字符串在for循环中使用+操作符进行拼接，那么每次循环都会产生一个新的字符串对象。这不仅浪费内存空间同时还会影响性能。类似的，如果初始化字符串对象，尽量不要使用构造方法，而应该直接初始化。比方说： //Slower Instantiation String bad = new String("Yet another string object");
//Faster Instantiation String good = "Yet another string object" |
| 3.避免无用对象 |
| 创建对象是Java中最昂贵的操作之一。因此最好在有需要的时候再进行对象的创建/初始化。如下： import java.util.ArrayList; import java.util.List;
public class Employees {
private List Employees;
public List getEmployees() {
//initialize only when required if(null == Employees) { Employees = new ArrayList(); } return Employees; } } |
| 4.数组与ArrayList |
| 开发人员经常会发现很难在数组和ArrayList间做选择。它们二者互有优劣。如何选择应该视情况而定。 import java.util.ArrayList;
public class arrayVsArrayList {
public static void main(String[] args) { int[] myArray = new int[6]; myArray[7]= 10; // ArraysOutOfBoundException
//Declaration of ArrayList. Add and Remove of elements is easy. ArrayList<Integer> myArrayList = new ArrayList<>(); myArrayList.add(1); myArrayList.add(2); myArrayList.add(3); myArrayList.add(4); myArrayList.add(5); myArrayList.remove(0);
for(int i = 0; i < myArrayList.size(); i++) { System.out.println("Element: " + myArrayList.get(i)); }
//Multi-dimensional Array int[][][] multiArray = new int [3][3][3]; } } 数组是定长的，而ArrayList是变长的。由于数组长度是固定的，因此在声明数组时就已经分配好内存了。而数组的操作则会更快一些。另一方面，如果我们不知道数据的大小，那么过多的数据便会导致ArrayOutOfBoundException，而少了又会浪费存储空间。ArrayList在增删元素方面要比数组简单。 数组可以是多维的，但ArrayList只能是一维的。 |
| 5.单引号与双引号的区别 |
| 看起来这段代码会返回”Haha”,但实际返回的是Ha169。原因就是用了双引号的时候，字符会被当作字符串处理，而如果是单引号的话，字符值会通过一个叫做基础类型拓宽的操作来转换成整型值。然后再将值相加得到169。 public class Haha { public static void main(String args[]) { System.out.print("H" + "a"); System.out.print('H' + 'a'); } } |
| 6.简单字符串查找 |
| Java提供了一个库函数叫做indexOf()。这个方法可以用在String对象上，它返回的是要查找的字符串所在的位置序号。如果查找不到则会返回-1。 |
| 7.一些防止内存泄露的小技巧 |
| 内存泄露会导致软件的性能降级。由于Java是自动管理内存的，因此开发人员并没有太多办法介入。不过还是有一些方法能够用来防止内存泄露的。 查询完数据后立即释放数据库连接 替Java省点内存 export JAVA_OPTS="$JAVA_OPTS -Xms5000m -Xmx6000m -XX:PermSize=1024m -XX:MaxPermSize=2048m" Xms = 最小内存分配Xmx = 最大内存分配 XX:PermSize = JVM启动时的初始大小 XX:MaxPermSize = JVM启动后可分配的最大空间 |
| 8.幂运算 |
| Java是通过异或操作来进行幂运算的。Java对于幂运算有两种处理方式： 乘积： double square = double a * double a; // Optimized double cube = double a * double a * double a; // Non-optimized double cube = double a * double square; // Optimized double quad = double a * double a * double a * double a; // Non-optimized double quad = double square * double square; // Optimized pow方法：在无法使用乘积的情况下可以使用pow方法。 double cube = Math.pow(base, exponent);
不到万不得已不要使用Math.pow。比方说，当指数是小数的时候。因为Math.pow要比乘积慢300-600倍左右。 |
| 9.尽量在合适的场合使用单例 |
| 使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面： 第一，控制资源的使用，通过线程同步来控制资源的并发访问； 第二，控制实例的产生，以达到节约资源的目的； 第三，控制数据共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信。 |
| 10.尽量避免随意使用静态变量 |
| 要知道，当某个对象被定义为static变量所引用，那么GC通常是不会回收这个对象所占有的内存，如： 此时静态变量b的生命周期与A类同步，如果A类不会卸载，那么b对象会常驻内存，直到程序终止。 |
| 11.尽量避免过多过常的创建Java对象 |
| 尽量避免在经常调用的方法，循环中new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理，在我们可以控制的范围内，最大限度的重用对象，最好能用基本的数据类型 |
| 12.尽量使用final修饰符 |
| 带有final修饰符的类是不可派生的。在JAVA核心API中，有许多应用final的例子，例如java.lang.String，为String类指定final防止了使用者覆盖length方法。另外，如果一个类是final的，则该类所有方法都是final的。java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50%。 或数组来替代对象。 |
| 13.尽量使用局部变量 |
| 调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量，实例变量等，都在堆（Heap）中创建，速度较慢。 |
| 14.尽量处理好包装类型和基本类型两者的使用场所 |
| 虽然包装类型和基本类型在使用过程中是可以相互转换，但它们两者所产生的内存区域是完全不同的，基本类型数据产生和处理都在栈中处理，包装类型是对象，是在堆中产生实例。在集合类对象，有对象方面需要的处理适用包装类型，其他的处理提倡使用基本类型。 |
| 15.慎用synchronized，尽量减小synchronize的方法 |
| 都知道，实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。synchronize方法被调用时，直接会把当前对象锁 了，在方法执行完之前其他线程无法调用当前对象的其他方法。所以synchronize的方法尽量小，并且应尽量使用方法同步代替代码块同步。 |
| 16.尽量不要使用finalize方法 |
| 实际上，将资源清理放在finalize方法中完成是非常不好的选择，由于GC的工作量很大，尤其是回收Young代内存时，大都会引起应用程序暂停，所以再选择使用finalize方法进行资源清理，会导致GC负担更大，程序运行效率更差。 |
| 17.尽量使用基本数据类型代替对象 |
| String str = “hello”; 上面这种方式会创建一个“hello”字符串，而且JVM的字符缓存池还会缓存这个字符串； String str = new String(“hello”); 此时程序除创建字符串外，str所引用的String对象底层还包含一个char数组，这个char数组依次存放了h,e,l,l,o |
| 18.多线程在未发生线程安全前提下应尽量使用HashMap、ArrayList |
| HashTable、Vector等使用了同步机制，降低了性能。 |
| 19.尽量减少对变量的重复计算 |
| 如：应该改为 并且在循环中应该避免使用复杂的表达式，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。 |
| 20.尽量在finally块中释放资源 |
| 程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。 |
| 21.尽量使用移位来代替’a/b’的操作 |
| “/”是一个代价很高的操作，使用移位的操作将会更快和更有效 |
| 22.尽量确定StringBuffer的容量 |
| StringBuffer 的构造器会创建一个默认大小（通常是16）的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再 丢弃旧的数组。在大多数情况下，你可以在创建 StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。 |
| 23.尽量避免使用二维数组 |
| 二维数据占用的内存空间比一维数组多得多，大概10倍以上。 |
| 24.尽量避免使用split |
| 除非是必须的，否则应该避免使用split，split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需要频繁的调用split，可以考虑使用apache的StringUtils.split(string,char)，频繁split的可以缓存结果。 |
| 25.尽量使用System.arraycopy 代替通过来循环复制数组 |
| System.arraycopy 要比通过循环来复制数组快的多 |
| 26.慎用异常 |
| 当创建一个异常时，需要收集一个栈跟踪(stack track)，这个栈跟踪用于描述异常是在何处创建的。构建这些栈跟踪时需要为运行时栈做一份快照，正是这一部分开销很大。当需要创建一个 Exception 时，JVM 不得不说：先别动，我想就您现在的样子存一份快照，所以暂时停止入栈和出栈操作。栈跟踪不只包含运行时栈中的一两个元素，而是包含这个栈中的每一个元素。 如果您创建一个 Exception ，就得付出代价。好在捕获异常开销不大，因此可以使用 try-catch 将核心内容包起来。从技术上讲，您甚至可以随意地抛出异常，而不用花费很大的代价。招致性能损失的并不是 throw 操作——尽管在没有预先创建异常的情况下就抛出异常是有点不寻常。真正要花代价的是创建异常。幸运的是，好的编程习惯已教会我们，不应该不管三七二十一就抛出异常。异常是为异常的情况而设计的，使用时也应该牢记这一原则。 |
| 27.尽量重用对象 |
| 特别是String对象的使用中，出现字符串连接情况时应使用StringBuffer代替，由于系统不仅要花时间生成对象，以后可能还需要花时间对这些对象进行垃圾回收和处理。因此生成过多的对象将会给程序的性能带来很大的影响。 |
| 28.不要重复初始化变量 |
| 默认情况下，调用类的构造函数时，java会把变量初始化成确定的值，所有的对象被设置成null，整数变量设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键字创建一个对象时，构造函数链中的所有构造函数都会被自动调用。 |
| 29.合理使用java.util.Vector |
| Vector与StringBuffer类似，每次扩展容量时，所有现有元素都要赋值到新的存储空间中。Vector的默认存储能力为10个元素，扩容加倍。 vector.add(index,obj) 这个方法可以将元素obj插入到index位置，但index以及之后的元素依次都要向下移动一个位置（将其索引加 1）。 除非必要，否则对性能不利。同样规则适用于remove(int index)方法，移除此向量中指定位置的元素。将所有后续元素左移（将其索引减 1）。返回此向量中移除的元素。所以删除vector最后一个元素要比删除第1个元素开销低很多。删除所有元素最好用removeAllElements方法。 如果要删除vector里的一个元素可以使用 vector.remove(obj)；而不必自己检索元素位置，再删除，如int index = indexOf（obj）;vector.remove(index)； |