jdk1.5相比jdk1.4多的新特性

"JDK1.5"（開發代號猛虎）的一個重要主題就是經過新增一些特性來簡化開發，這些特性包括泛型，for-each 循環，自動裝包/拆包，枚舉，可變參數, 靜態導入 。使用這些特性有助於咱們編寫更加清晰，精悍，安全的代碼。

自動裝箱/拆箱(Autoboxing/unboxing)

自動裝箱：基本類型自動轉換爲包裝類

自動拆包：包裝類自動轉換爲基本類型

package com.linjunlong.fun.jdk15;

import java.util.ArrayList;


/**
 * 功能：自動裝箱/拆箱
 * 編譯器自動進行基本類型和對應的包裝類型進行轉換
 * byte      <-->   Byte
 * short     <-->   Short
 * int       <-->   Integer
 * long      <-->   Long
 * float     <-->   Float
 * double    <-->   Double
 * char      <-->   Character
 * boolean   <-->   Boolean
 *  
 * @author linjunlong.com
 */
public class AutoBoxingOrUnBoxing {
    
    /**
     * 這裏咱們以Integer爲實例
     */
    public void jdk14() {
        //在jdk1.4中,初始話一個值類型對應的包裝類，你須要這麼寫
        Integer integer = new Integer(1);
        int i = integer.intValue();
        //若是你須要在數組中添加一個數值類型的話，你還須要把他轉成基礎類型
        new ArrayList().add(new Integer(i));
    }
    
    public void jdk15() {
        //在jdk1.5中你能夠這麼寫; int --> Integer
        Integer integer = 1;
        // Integer --> int
        int  i = integer;
        //這裏你能夠直接添加數值類型
        new ArrayList().add(i);
    }
    
    public static void main(String[] args) {
        /*
         * 這裏有一些有趣的特性，享元模式，
         * 通過裝箱和解箱的對象只要大小在-128到127之間（byte類型的範圍之間）
         * 都會在jvm內存的對象緩存池裏造成記錄，下次有裝箱和解箱行爲的對象，
         * 都會直接指向這個緩存次裏的對象
         */
        
        Integer num1 = 20;
        int num2 = new Integer(20);
        System.out.println( num1 == num2); //@answer1
        Integer int1 = new Integer(20);
        Integer int2 = new Integer(20);
        System.out.println( int1 == int2); //@answer2
        System.out.println(num1 == int1); //@answer3
        System.out.println(num1 == int1*1);//@answer4
        
        
        //->answer1:true num1和num2都通過了裝箱和解箱，都指向緩存池裏的對象20
        //->answer2:false int1和int2 沒通過裝箱和解箱，2個是不一樣的對象，比較他們的引用地址確定也不同
        //->ansewr3:false 一個在的引用地址指向緩存池，一個是指向對象[20]的引用地址2個也不相等
        //->answer4:true 後面int1通過了解箱而後*1運算，而後又裝箱成Integer類型，因此他的引用地址也是緩存池裏的地址
    }

}

靜態導入(Static Imports)

package com.linjunlong.fun.jdk15;

import static java.lang.Integer.*; //導入了Integer的全部靜態方法和靜態屬性
import static java.lang.Math.max;  //導入了Math的max方法

/**
 * 功能：靜態導入
 * 你能夠導入一些靜態方法和屬性來看成類自己的方法和屬性同樣調用
 * 
 * @author linjunlong.com
 */
public class StaticImports {
	
	/**
	 * 這裏咱們以Integer的對象和方法爲例
	 */
	public void jdk14() {
		//在jdk1.4中你基本上只能這麼寫
		Math.max(Integer.MAX_VALUE, Integer.MIN_VALUE);
		Integer.parseInt("12");
	}
	
	public void jdk15() {
		//在jdk1.5中你只要導入了相應的對象和方法你就能夠直接寫了
		max(MAX_VALUE, MIN_VALUE);
		parseInt("12");
	}
	
}

For-Each循環

package com.linjunlong.fun.jdk15;


/**
 * 功能：ForEach循環
 * 
 * @author linjunlong.com
 */
public class ForEach {
    
    /**
     * 例如在jdk1.4中，咱們須要遍歷一個數組，或集合，用for循環的話，咱們基本只能這麼寫
     */
    public static void jdk14(String[] strs) {
        for(int i = 0,max = strs==null?0:strs.length 
                ; i < max ; i ++) {
            System.out.print(strs[i]);
        }
    }
    
    public static void jdk15(String[] strs) {
        //jdk1.5中咱們能夠
        for(String s : strs) {
            System.out.print(s);
        }
    }
    
    public static void main(String[] args) {
        String[] strs = {"a","b","c"};
        ForEach.jdk14(strs);//abc
        ForEach.jdk15(strs);//abc
    }
    
}

可變長參數

package com.linjunlong.fun.jdk15;


/**
 * 功能：可變長參數
 * 一、方法的參數是能夠變長的
 * 二、可變長參數必定要是方法的最後一個參數
 * 
 * @author linjunlong.com
 */
public class VariableArguments {
    
    /**
     * 例如在jdk14中，若是須要傳一堆字符串
     * 這麼寫
     */
    public static void jdk14(String[] strs) {
        for(int i = 0,max = strs==null?0:strs.length 
                ; i < max ; i ++) {
            System.out.print(strs[i]);
        }
    }
    
    /**
     * 在jdk1.5中，咱們能夠這麼寫,注意String後面的3個點...
     * @param strs
     */
    public static void jdk15(String... strs) {
        for(int i = 0,max = strs==null?0:strs.length 
                ; i < max ; i ++) {
            System.out.print(strs[i]);
        }
    }
    
    public static void main(String[] args) {
        String[] strs = {"a","b","c"};
        VariableArguments.jdk14(strs);//abc
        VariableArguments.jdk15(strs);//abc
        //jdk15還能夠
        VariableArguments.jdk15("a","b","c");//abc
    }
    
}

枚舉

package com.linjunlong.fun.jdk15;


/**
 * 功能：枚舉
 * 枚舉類型，jdk1.5加入了一個新的關鍵字enmu，咱們能夠這樣來定義一個枚舉類型。
 * 
 * @author linjunlong.com
 */
public class Enums {
    
    //這裏用了靜態內部類，只是爲了方便寫例子
    public static enum Colors {
        Red,
        White,
        Blue
    }
    
    public static void main(String[] args) {
        //咱們能夠這樣使用枚舉
        Enums.Colors myColors = Enums.Colors.Red;
        System.out.println(myColors);
        for(Enums.Colors c : Enums.Colors.values()) {
            System.out.println(c);
        }
    }
}

泛型

package com.linjunlong.fun.jdk15;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 功能：泛型
 * C++經過模板技術能夠指定集合的元素類型，
 * 而Java在1.5以前一直沒有相對應的功能。
 * 一個集合能夠聽任何類型的對象，
 * 相應地從集合裏面拿對象的時候咱們也不得不對他們進行強制得類型轉換。
 * 猛虎引入了泛型，它容許指定集合裏元素的類型，
 * 這樣你能夠獲得強類型在編譯時刻進行類型檢查的好處。
 * 
 * @author linjunlong.com
 */
public class Generic {
    
    public static void jdk14(){
        //至關於15中的List<Object> list = new ArrayList<Object>();
        List list = new ArrayList();
        list.add("1");//咱們如今在list中添加了一個字符串類型
        String s = (String)list.get(0);//須要強轉
        list.add(new Date());//咱們還能夠添加一個Date類型
    }
    
    public static void jdk15(){
        List<String> list = new ArrayList<String>();
        list.add("1");
        String s = list.get(0);//不須要強轉
        //list.add(new Date());//編譯不經過
    }
}