eff java_EffactiveJava-避免创建不必要的对象

类是Java程序的基本组成单元，在程序运行过程中要通过创建大量的对象来执行整个系统的运行，单有些对象呗创建的代价是高昂的，例如数据库连接、Spring的ApplicationContext等，这类对象往往用单例强化成全局唯一，另外一些对象相对来说创建代价会小很多，例如

String s = new String("stringette");

上面的代码第一次执行是，会 创建两个对象，一个在堆中，一个在常量池，如果利用上面的代码创建字符串，那么每次运行都会在堆中创建一个新的对象，这完全没有必要，通常在创建字符串时，我们都是这样做的：

String s = "stringette";

这样只会在常量池中创建一个常量字符串，以后再创建相同内容 的字符串时都会引用该常量。

上面是重用不可变对象的列子，我们也可以重用那些已知不会被修改的对象，比如下面这个反例：

public class Person1 {

private final Date birthData = new Date();

public boolean isBabyBoomer(){

Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);

Date boomStart = gmtCal.getTime();

gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);

Date boomEnd = gmtCal.getTime();

return birthData.compareTo(boomStart) >= 0 && birthData.compareTo(boomEnd) < 0;

}

public static void main(String[] args) {

Person1 person = new Person1();

long start = System.currentTimeMillis();

for(int i = 0;i < 10000;i ++){

person.isBabyBoomer();

}

long end = System.currentTimeMillis();

System.out.println(end - start);

}

}

整个循环的执行时间是183ms，在运行过程中，会频繁的创建Calendar对象，重点在于当中的两个Calendar对象在每次循环创建是，内容都是一样的。在比较一下改进后的版本：

public class Person2 {

private final Date birthDate = new Date();

private static final Date BOOM_START;

private static final Date BOOM_END;

static {

Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);

BOOM_START = gmtCal.getTime();

gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);

BOOM_END = gmtCal.getTime();

}

public boolean isBabyBoomer(){

return birthDate.compareTo(BOOM_START) >= 0 &&

birthDate.compareTo(BOOM_END) < 0;

}

public static void main(String[] args) {

Person2 person = new Person2();

long start = System.currentTimeMillis();

for(int i = 0;i < 10000; i ++){

person.isBabyBoomer();

}

long end = System.currentTimeMillis();

System.out.println(end - start);

}

}

上面的代码在本地运行时间为1ms，差距大都惊人的地步！

在JDK1.5中，Java引入了自动装箱拆箱功能，每一种基本数据类型都对应一个包装的对象类型，转换过程有Java自动完成，这使得在开发的过程中 基本数据类型 和 对应的包装数据类型的界限变得更加模糊，当相比基本数据类型而言，包装类型的创建代价要高的多，因为内部维护了更多的状态，同时，包装类型与基本类型的抽象层次更高，来看一下下面的例子：

public static void main(String[] args) {

Long sum = 0l;

long start = System.currentTimeMillis();

for(long i = 0;i < Integer.MAX_VALUE; i ++){

sum += i;

}

System.out.println(sum);

long end = System.currentTimeMillis();

System.out.println(end - start);

}

上面的代码在运行时，大约创建了2^31个Long对象，耗时12s，下面我们将Long改成long再试一次

public static void main(String[] args) {

long sum = 0l;

long start = System.currentTimeMillis();

for(long i = 0;i < Integer.MAX_VALUE; i ++){

sum += i;

}

System.out.println(sum);

long end = System.currentTimeMillis();

System.out.println(end - start);

}

以上代码耗时919ms。

总结：

1. 避免创建创建相同的不可变对象(String)

2. 复用不会被改变的对象

3. 优化使用基本数据类型而不是包装类型，注意自动装箱。

当然，也不是要到处都尽量避免重复创建对象，对于小对象的创建，当前的JVM还是很快的，通过创建附加对象，可以提升程序的清晰度、简洁性和功能性。