類是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還是很快的，通過建立附加物件，可以提升程式的清晰度、簡潔性和功能性。