JDK5的新特性

本篇博客内容

　　一、自动装箱和自动拆箱

　　二、泛型

　　三、增强for循环

　　四、静态导入

　　五、可变参数

　　六、枚举

一、自动装箱和自动拆箱 <=返回目录

　　java有8种基本数据类型 byte、short、int、long、float、double、char、boolean，

　　对应的有8种包装类型 Byte、Short、Integer、Long、Float、Double、Character、Boolean。

　　所谓自动装箱就是：将基本数据类型的值直接赋值给对应包装类型的变量，java自动进行转换。（自动装箱：基本数据类型 ==> 包装类型）

　　自动拆箱：将包装类型的值赋给基本数据类型的变量，java自动进行转换。（自动拆箱：包装类型 ==> 基本数据类型）

// 自动装箱
Integer a = 1;
// 执行上面那句代码的时候，系统为我们执行了： 
// Integer a = Integer.valueOf(1); // 装箱 int ==> Integer

// 自动拆箱
int b = a;
// 执行上面那句代码的时候，系统为我们执行了：
// int b = a.intValue(); // 拆箱 Integer ==> int

Integer i = 1;
i += 1; // 先拆 i+1，再装i=i+1
//执行上面那句代码的时候，系统为我们执行了：
i = Integer.valueOf(i.intValue() + 1);

二、泛型 <=返回目录

　　泛型（一）泛型类和泛型方法

　　泛型（二）封装工具类CommonUtils-把一个Map转换成指定类型的javabean对象

　　泛型（三）模拟commons-dbutils

　　泛型（四）类型通配符

　　泛型（五）

三、增强for循环 <=返回目录

　　使用增强for时，先对要进行遍历的数据进行判空判断。

package com.oy.test;

public class Test {

    public static void main(String[] args) {
        String[] strArray = new String[] {"a", "b", "c"};
        // printArray(strArray);
        printArray2(strArray);
        
        Integer[] intArray = new Integer[] {1, 2 ,3};
        // printArray(intArray);
        printArray2(intArray);
        
        // printArray种使用增强for的代码不严谨，比如：
        Object[] objArray = null;
        // printArray(objArray); // 报错NullPointerException
        printArray2(objArray);
    }
    
    // 使用增强for的代码不严谨
    private static void printArray(Object[] objArray) {
        for (Object str : objArray) {
            System.out.println(str);
        }
    }
    
    // 改进
    private static void printArray2(Object[] objArray) {
        if (objArray != null && objArray.length > 0) {
            for (Object str : objArray) {
                System.out.println(str);
            }
        }
    }
}

四、静态导入 <=返回目录

　　自定义工具类，包含一个静态方法

package com.oy.util;

import java.util.UUID;
public class Utils {
    // 获取UUID，32位字符串
    public static String uuid() {
        return UUID.randomUUID().toString().replace("-", "").toUpperCase();
    }
}

　　静态导入格式: import 包名.类名.方法名;

package com.oy.test;

// import com.oy.util.Utils; // 原来是导入类
// 静态导入是：导入方法
// 静态导入格式: import 包名.类名.方法名;
import static com.oy.util.Utils.uuid;

public class Test {
    public static void main(String[] args) {
        String str = uuid();
        System.out.println(str);
    }
    
}

五、可变参数 <=返回目录

　　可变参数本质是一个数组

public class Test {

    public static void main(String[] args) {
        System.out.println(add(1)); // 1
        System.out.println(add(1, 2)); // 3
        System.out.println(add(1, 2, 3)); // 6
        
        System.out.println(add(new int[] {1, 2})); // 3
        
        // System.out.println(add(1, new int[] {2, 3})); // 报错
    }
    
    private static int add(int... intArray) {
        int sum = 0;
        for (int i : intArray) {
            sum += i;
        }
        return sum;
    }
}

　　可变参数只能作为方法的最后一个参数

public class Test {

    public static void main(String[] args) {
        System.out.println(add(1)); // 1
        System.out.println(add(1, 2)); // 3
        System.out.println(add(1, 2, 3)); // 6
        
        System.out.println(add(1, new int[] {2, 3})); // 6
    }
    
    // 可变参数只能作为方法的最后一个参数
    // private static int add(int a, int... intArray, int b) { // 报错
    private static int add(int a, int... intArray) {
        int sum = 0;
        sum += a;
        for (int i : intArray) {
            sum += i;
        }
        return sum;
    }
}

　　int compareTo(E o)
　　String name(): 返回次枚举常量的名称
　　int ordinal(): 返回此枚举常量的编号
　　String toString()：返回此枚举常量的名称
　　<T> T valueOf(Class<T> type, String name)
　　values() : 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

public class Test {
    public static void main(String[] args) {
        // int compareTo(E o)
        Direction d1 = Direction.FRONT; // 编号0
        Direction d2 = Direction.BEHIND; // 编号1
        Direction d3 = Direction.LEFT; // 编号2
        Direction d4 = Direction.RIGHT; // 编号3
        
        System.out.println(d1.compareTo(d1)); // 0-0=0
        System.out.println(d1.compareTo(d2)); // 0-1=-1
        System.out.println(d1.compareTo(d3)); // 0-2=-2
        System.out.println(d1.compareTo(d4)); // 0-3=-3
        
        // String name(): 返回此枚举常量的名称
        System.out.println("d2.name: " + d2.name()); // BEHIND
        
        // int ordinal(): 返回此枚举常量的编号
        System.out.println("d3.ordinal: " + d3.ordinal()); // 2
        
        // String toString()
        System.out.println("d2.toString: " + d2.toString()); // BEHIND
        
        // <T> T valueOf(Class<T> type, String name)
        //java.lang.IllegalArgumentException: No enum constant com.oy.test.Direction.LEFT1
        // Direction d5 = Direction.valueOf("LEFT1");
        Direction d5 = Direction.valueOf("LEFT");
        System.out.println("d5: " + d5);
        
        // 遍历枚举类
        Direction[] directs = Direction.values();
        int i = 0;
        for (Direction dire : directs) {
            System.out.println("directs[" +  (i++) + "]=" + dire.toString());
        }
    }
}

　　结果：

0
-1
-2
-3
d2.name: BEHIND
d3.ordinal: 2
d2.toString: BEHIND
d5: LEFT
directs[0]=FRONT
directs[1]=BEHIND
directs[2]=LEFT
directs[3]=RIGHT

参考：

　　（1）详解Java的自动装箱与拆箱(Autoboxing and unboxing)

　　（2）java enum(枚举)使用详解 + 总结