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)); //

        System.out.println(add(1, 2)); //

        System.out.println(add(1, 2, 3)); //

        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)); //

        System.out.println(add(1, 2)); //

        System.out.println(add(1, 2, 3)); //

        System.out.println(add(1, new int[] {2, 3})); //

    }

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

    // 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(枚举)使用详解 + 总结