Java之JDK新特性

JDK5.0新特性

 

JDK5中新增了很多新的java特性，大致如下：

1、静态导入  2、自动装箱/拆箱   3、增强for循环  4、可变参数  5、枚举   6、泛型

 

一、静态导入

    JDK 1.5 增加的静态导入语法用于导入类的某个静态属性或方法，使用静态导入可以简化程序对类静态属性和方法的调用。

1、什么是静态导入

是指可以import类的静态方法和静态变量，在使用时无须指定类名便可以使用这些被import的静态方法和静态变量，这就是静态导入

2、静态导入的好处

a) 写import语句时，可以定位到一个静态方法或静态变量（以前是定位到类）

b) 可以使用通配符（*）代表导入该类的所有静态方法和静态变量

c) 使用静态导入可以简化程序对类静态属性和方法的调用

3、语法

    import static 包名.类名.静态属性|静态方法|*

4、注意

不允许静态方法和静态变量出现重名的情况

如果静态导入的成员与本类的方法同名，优先使用本类的成员，静态导入这时失效（和方法的参数无关，同名就会失效）

/********静态导入过程演示*******/

import static java.lang.Math.max;  //导入了Math的max方法

import static java.lang.Math.min;  //导入了Math的min方法

import static java.lang.Integer.*; //导入了Integer的所有静态方法和静态属性

public class StaticImport {

       public static void main(String[] args){

              //通过静态导入使用Math的静态方法，这里不再是Math.max(5,10)了

              System.out.println(max(5,10));

              System.out.println(min(5,10));

              //通过静态导入使用Integer的静态方法

              System.out.println(parseInt("55544555"));

              System.out.println(toBinaryString(2354));

              //通过静态导入使用Integer的静态属性

              System.out.println(MAX_VALUE);

              System.out.println(MIN_VALUE);

       }

}

 

 

二、增强for循环1、引入增强for循环的原因：

    在JDK5以前的版本中，遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦！因此JDK5中定义了一种新的语法——增强for循环，以简化此类操作。

2、用法

    增强for循环只能用在数组、或实现Iterable接口的集合类上

3、语法格式

    for(变量类型 变量　：需迭代的数组或集合){}

4、增强for循环的好处

    是为了让你的代码变得简捷、和容易维护。不过其运行速度跟普通遍历的速度是一致的。

/********增强for循环过程演示*******/

import java.util.ArrayList;

import java.util.List;

 

/**

* 新的for循环,格式为for(type x:type y)

* 表示遍历数组或集合y的元素,把元素值赋给x

*/

public class ForEach {

       /**对整数数组求和*/

       public static long getSum(int[] nums) throws Exception{

              if(nums == null)

                     throw new Exception("错误的参数输入,不能为null!");

              long sum = 0;

              //依次取得nums元素的值并累加

              for(int x : nums){

                     sum += x;

              }

              return sum;

       }

       /**对整数列表求和*/

       public  static long getSum(List<Integer> nums) throws Exception{

              if(nums == null)

                     throw new Exception("错误的参数输入,不能为null!");

              long sum = 0;

              //可以与遍历数组一样的方式遍历列表

              for(int x:nums){

                     sum += x;

              }

              return sum;

       }

       /**求多维数组的平均值*/

       public static int getAvg(int[][] nums) throws Exception{

              if(nums == null)

                     throw new Exception("错误的参数输入,不能为null!");

              long sum = 0;

              long size = 0;

              //对于二维数组,每个数组元素都是一维数组

              for(int[] x : nums){

                     //一维数组中的元素才是数字

                     for(int y : x){

                            sum += y;

                            size ++;

                     }

              }

              return (int)(sum/size);

       }

      

       public static void main(String[] args) throws Exception {

              int[] nums = {456,23,-739,163,390};

              List<Integer> list_I = new ArrayList<Integer>();

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

                     list_I.add(nums);

              }

              System.out.println(getSum(nums));

              System.out.println(getSum(list_I));

              int[][] numss = {{1,2,3},{4,5,6},{7,8,9,10}};

              System.out.println(getAvg(numss));

       }

}

 

三、可变参数1、作用

   在J2SE5.0之前,当传入到方法的参数个数不固定时,经常采用数组的方式传递参数

   在J2SE5.0之后,可以使用可变参数的给方法传递参数

2、语法

语法：数据类型…变量名

3、细节

    a) 声明：

                在一个方法中，最多只能有一个可变参数。

                可变参数只能放在参数列表的最后面。

        b) 调用：

                当使用可变参数时，可以传0或多个参数。

                当使用可变参数时，也可以传一个数组进去，就表示多个参数。

        c) 使用：

                在方法内部使用时，就是在使用一个数组。

        当调用时没有传参数时（传了0个），这时在方法内部的参数数组是有值的（不为null），但长度为0

d) 特别强调：

一个方法里最多只能有一个变长参数,而且这个变长参数一定要放在参数表的最后一个参数

/********静态导入过程演示*******/

/**

* 在参数类型和参数名之间使用"..."(三个英文的点),表示该参数为可变长的

* 通过新的for循环读取可变长参数中的值

*/

import static java.lang.System.*;

public class VarArgs {

    public static void print(Integer... s){

        for(int s2:s){     //解封

            out.print(s2+"\t");

        }

        out.println();

    }

    public static void main(String... args) {

      print();      //调用public static void print()方法

      print(1);     //调用public static void print(Integer i)方法  封箱

      print(2,3);   //调用public static void print(Integer... s)方法 封箱

      print(4,5,6);//调用public static void print(Integer... s)方法 封箱

    }

}

4、自动装箱/拆箱

自动装箱：指开发人员可以把一个基本数据类型直接赋给对应的包装类。

自动拆箱：指开发人员可以把一个包装类对象直接赋给对应的基本数据类型。

1、JDK5.0后出现了自动装箱和拆箱，简化了定义方式

    Integer x = new Integer(5);  //装箱

        int intValue = x.intValue(); //拆箱

        // 5.0简化书写    自动装箱。new Integer(5);

        Integer y = 5;  

        // 对象加整数,x 进行了自动拆箱,变成了int 型 和5进行加法运算后再将和进行装箱赋给x。

        y = y + 5; // 是通过Integer.intValue() 方法进行拆箱

2、需要注意的细节：

a) Integer的缓存大小在-128 ~127 之间也就是byte的范围。

b) 基本类型的数据值可以直接赋给基本数据对象,基本数据的对象也可以直接赋给基本数据变量

c) 在表达式中,基本类型的数据值可以和基本数据对象进行运算

d) 基本数据类型的数组不能实现自动装箱和拆箱,即int[]不能当成Integer[]使用  

3、典型应用：

        List list = new ArrayList();

        list.add(1);                    //替换了 list.add(new Integer(1));

        int i=list.get(0);        //替换了 int j = (Integer)list.get(0);

 

5、基本数据类型包装类

包装类                                                                                基本数据类型

Byte	byte
Short	short
Integer	int
Long	long
Boolean	boolean
Float	float
Double	double
Character	char
对象变基本数据类型:拆箱	基本数据类型包装为对象:装箱

 

a) 目标：

为了使得java的基本类型有更多的功能，java为其所有的基本类型提供了包装类来封装常见的功能。如：最大值、数值转换等

b) 好处：

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

包装类所属的包为：java.lang.*

 

应用一:

获取最大最小值：MAX_VALUE / MIN_VALUE

整数类型最大值：Integer.MAX_VALUE

System.out.println(Integer.MIN_VALUE); // -2147483648

System.out.println(Integer.MAX_VALUE); // 2147483647

应用二:

基本数据类型和字符串之间的转换

1、基本数据类型转换成字符串: // Integer的parseInt方法，intValue方法

a) 基本数据类型+””

        int i=100;

        String str=100+"";

b) 基本数据类型.toString(基本数据类型值);

        String string = Integer.toString(100);

        Integer.toString(34); //将34变成了”34”

2、字符串变基本数据类型：

a) 语法：

基本数据类型 a = 基本数据类型包装类.parse基本数据类型(String str);

        str="123";

                int parseInt = Integer.parseInt(str);

        System.out.println(parseInt);

        double parseInt2 = Double.parseDouble(str);

        boolean b = Boolean.parseBoolean("true");

        注意: Integer类中的parseInt方法是静态的 参数必须是数字格式

               // public static int parseInt(String s)

应用三:

进制转换:

1、十进制转成其他进制

toBinaryString(int i)
          以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。

toHexString(int i)
          以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。

toOctalString(int i)
          以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。  

/********演示十进制转成其他进制转换过程*******/

// 十进制转二进制

String binaryString = Integer.toBinaryString(100);

System.out.println(binaryString); // 1100100

// 十进制转十六进制

String hexString = Integer.toHexString(100);

System.out.println(hexString); // 64

// 十进制转八进制

String octalString = Integer.toOctalString(100);

System.out.println(octalString); // 144

2、其他进制转成十进制

parseInt(String radix);

parseInt(String s, int radix)
          使用第二个参数指定的基数，将字符串参数解析为有符号的整数。

/********演示其他进制转十进制转换过程*******/

// 字符串转对应的进制

int parseInt3 = Integer.parseInt(octalString);

System.out.println(parseInt3);

// 二进制转十进制

int parseInt4 = Integer.parseInt(binaryString, 2);

System.out.println(parseInt4);

// 十六进制转十进制

int parseInt5 = Integer.parseInt(hexString, 16);

System.out.println(parseInt5);

// 八进制转十进制

int parseInt6 = Integer.parseInt(octalString, 8);

System.out.println(parseInt6);

四、枚举类

枚举类特别注意事项：

*enum关键字表示枚举类型，它的作用相当于类声明中的class关键字

*枚举类型不能有public的构造方法

*所有的枚举值都是public、static、final的,这些修饰符都是自动加上,无须程序员手动添加

*枚举值之间用逗号","分开,最后一个枚举值后面接分号";"

*每一个枚举值是一个枚举类型的实例

*可以在枚举类型中定义非枚举值变量,这些变量可以使用任何修饰符

*变量和方法的定义必须在枚举值后面定义

 

1、枚举主要的7种方法

用法一：常量

在JDK1.5 之前，我们定义常量都是： public static fianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

public enum Color {  

    RED, GREEN, BLANK, YELLOW  

}

用法二：switch

JDK5中扩展了swith语句，它除了可以接收int, byte, char, short外，还可以接收一个枚举类型(enum)。

enum Signal {

    GREEN, YELLOW, RED

}

public class TrafficLight {

    Signal color = Signal.RED;

    public void change() {

        switch (color) {

        case RED:

            color = Signal.GREEN;

            break;

        case YELLOW:

            color = Signal.RED;

            break;

        case GREEN:

            color = Signal.YELLOW;

            break;

        }

    }

}

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。

public enum Color {

        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);

        // 成员变量

        private String name;

        private int index;

        // 构造方法

        private Color(String name, int index) {

            this.name = name;

            this.index = index;

        }

        // 普通方法

        public static String getName(int index) {

            // values() ： 返回所有Color类型的数组

            for (Color c : Color.values()) {

                if (c.getIndex() == index) {

                    return c.name;

                }

            }

            return null;

        }

        // get set 方法

        public String getName() {

            return name;

        }

        public void setName(String name) {

            this.name = name;

        }

        public int getIndex() {

            return index;

        }

        public void setIndex(int index) {

            this.index = index;

        }

    }

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。

public class Test {

    public enum Color {

        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);

        // 成员变量

        private String name;

        private int index;

 

        // 构造方法

        private Color(String name, int index) {

            this.name = name;

            this.index = index;

        }

        // 覆盖方法

        @Override

        public String toString() {

            return this.index + "_" + this.name;

        }

    }

 

    public static void main(String[] args) {

        System.out.println(Color.RED.toString());

    }

}

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。

public interface Behaviour {

    void print();

    String getInfo();

}

 

public enum Color implements Behaviour {

    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);

    // 成员变量

    private String name;

    private int index;

    // 构造方法

    private Color(String name, int index) {

        this.name = name;

        this.index = index;

    }

    // 接口方法

    @Override

    public String getInfo() {

        return this.name;

    }

    // 接口方法

    @Override

    public void print() {

        System.out.println(this.index + ":" + this.name);

    }

}

用法六：使用接口组织枚举

public interface Food {

    enum Coffee implements Food {

        BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO

    }

    enum Dessert implements Food {

        FRUIT, CAKE, GELATO

    }

}

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复;EnumMap中的 key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档

 

2、枚举和常量定义的区别

一、 通常定义常量方法

我们通常利用public final static方法定义的代码如下，分别用1表示红灯，3表示绿灯，2表示黄灯。

public class Light {

    /* 红灯 */

    public final static int RED = 1;

    /* 绿灯 */

    public final static int GREEN = 3;

    /* 黄灯 */

    public final static int YELLOW = 2;

}

二、 枚举类型定义常量方法

枚举类型的简单定义方法如下，我们似乎没办法定义每个枚举类型的值。比如我们定义红灯、绿灯和黄灯的代码可能如下：

public enum Light {

    RED, GREEN, YELLOW;

}

我们只能够表示出红灯、绿灯和黄灯，但是具体的值我们没办法表示出来。别急，既然枚举类型提供了构造函数，我们可以通过构造函数和覆写toString方法来实现。首先给Light枚举类型增加构造方法，然后每个枚举类型的值通过构造函数传入对应的参数，同时覆写toString方法，在该方法中返回从构造函数中传入的参数，改造后的代码如下：

public enum Light {

    // 利用构造函数传参

    RED(1), GREEN(3), YELLOW(2);

    // 定义私有变量

    private int nCode;

    // 构造函数，枚举类型只能为私有

    private Light(int _nCode) {

        this.nCode = _nCode;

}

 

    @Override       

    public String toString() {

        // 返回带指定名称的指定枚举类型的枚举常量

        return String.valueOf(this.nCode);

    }

}

3、 完整示例代码

枚举类型的完整演示代码如下：

public class LightTest {

    // 1.定义枚举类型

    public enum Light {

        // 利用构造函数传参

        RED(1), GREEN(3), YELLOW(2);

        // 定义私有变量

        private int nCode;

        // 构造函数，枚举类型只能为私有

        private Light(int _nCode) {

            this.nCode = _nCode;

        }

 

        @Override

        public String toString() {

            return String.valueOf(this.nCode);

        }

    }

 

    public static void main(String[] args) {

        // 1.遍历枚举类型

        System.out.println("演示枚举类型的遍历 ......");

        testTraversalEnum();

        // 2.演示EnumMap对象的使用

        System.out.println("演示EnmuMap对象的使用和遍历.....");

        testEnumMap();

        // 3.演示EnmuSet的使用

        System.out.println("演示EnmuSet对象的使用和遍历.....");

        testEnumSet();

    }

 

    /**      

     * 演示枚举类型的遍历

     */

    private static void testTraversalEnum() {

        // values() ： 返回枚举的所有枚举常量

        Light[] allLight = Light.values();

        for (Light aLight : allLight) {

            System.out.println("当前灯name：" + aLight.name());

            // ordinal() ： 返回枚举常量的序数（初始常量的序数为0）

            System.out.println("当前灯ordinal：" + aLight.ordinal());

            System.out.println("当前灯：" + aLight);

        }

    }

 

    /**      

     * 演示EnumMap使用，EnumMap跟HashMap的使用差不多，只不过key要是枚举类型

     */

    private static void testEnumMap() {

        // 1.定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认key的类

              的类型

        EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(

        Light.class);

        currEnumMap.put(Light.RED, "红灯");

        currEnumMap.put(Light.GREEN, "绿灯");

        currEnumMap.put(Light.YELLOW, "黄灯");

 

        // 2.遍历对象

        for (Light aLight : Light.values()) {

            System.out.println("[key=" + aLight.name() + ",value="

            + currEnumMap.get(aLight) + "]");

        }

    }

 

    /**      

     * 演示EnumSet如何使用，EnumSet是一个抽象类，获取一个类型的枚举类型内容

     * 可以使用allOf方法

     */

    private static void testEnumSet() {

        EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);

        for (Light aLightSetElement : currEnumSet) {

            System.out.println("当前EnumSet中数据为：" + aLightSetElement);

        }

    }

}

枚举扩展案例完美版

public class EnumType {

        /** 人Person的枚举类型 */

        enum Person {

                CHINESE,   // 中国人

                AMERICAN, // 美国人

                ENGLISH;  // 英国人

        }

 

        public static void main(String[] args) {

                System.out.println("Persion枚举值的数目: " + Person.values().length);

                // 遍历枚举类型中的所有值

                System.out.println("Person枚举值如下: ");

                Person[] ps = Person.values(); //values()方法返回Person类型的数组

                for (Person p : ps) {

                        System.out.print(p + " "); //toString()方法返回枚举值的名称,此处打印CHINESE  AMERICAN  ENGLISH

                }

                System.out.println();

                Person p = Person.CHINESE;

                // 比较枚举值

                if (p == Person.CHINESE) {

                        System.out.println("p' value equals Person.CHINESE");

                }

                // 使用valueOf获得字符串描述的枚举值

                p = Person.valueOf("AMERICAN");

                // 在switch中使用枚举值

                // switch中可以放置的类型有byte,short,int,char,enum,注意没有long

                switch (p) {

                case CHINESE:

                        System.out.println("p is Chinese");

                        break;

                case AMERICAN:

                        System.out.println("p is American");

                        break;

                case ENGLISH:

                        System.out.println("p is English");

                        break;

                }

                // 获得枚举值在枚举类型中声明的顺序

                System.out.println("AMERICAN的序号: " + Person.AMERICAN.ordinal());

                System.out.println("CHINESE的序号: " + Person.CHINESE.ordinal());

                System.out.println("ENGLISH的序号: " + Person.ENGLISH.ordinal());

 

                // 使用更复杂的枚举类型ComplexPerson

                ComplexPerson cp = ComplexPerson.CHINESE;

                // 因为为CHINESE枚举值覆盖了toString()方法,所以调用的是CHINESE的toString方法

                System.out.println("cp.toString(): " + cp);

                cp = ComplexPerson.AMERICAN;

                // 因为没有为AMERICAN枚举值覆盖toString方法,所以调用默认的toSting方法

                cp = ComplexPerson.OTHER;

                System.out.println("cp.getValue(): " + cp.getValue());

        }

 

        /** 一个更复杂的枚举类型 */

        enum ComplexPerson {

                // 枚举值

                // CHINESE的value属性为"中国人"

                CHINESE("中国人") {

                        public String toString() {

                                return "这是个中国人";

                        }

                },

                AMERICAN("美国 人"), ENGLISH("英国人") {

                        public String toString() {

                                return "这是个英国佬";

                        }

                },

                OTHER {

                        public String toString() {

                                return "这是个其它国家的人";

                        }

                };

                private String value = null; // 枚举类值的value属性,只能声明在枚举值的后面

 

                // 默认的构造方法

                ComplexPerson() {

                        value = "其他人";

                }

 

                // 带参数的构造方法

                ComplexPerson(String value) {

                        this.value = value;

                }

 

                // 获取value属性

                public String getValue() {

                        return this.value;

                }

        }

}

 

(来源：黑马程序员广州中心）