jdk1.5之后新特性总结

      前两天 面试的时候面试官突然问我jdk1.5之后的一些新特性，让我一时语塞 （啥新特性啊？？？），回来后于是查找了一下资料，不由让我汗颜 ，发现其实很多都用过只是平时没注意，特此总结一下，在java中，至从jdk1.5之后便出现了一些新特性
包括：泛型(Generic) ，注解，For-Each，自动拆箱和装箱，静态导入，格式化打印，枚举，可变参数...
1.泛型(Generic)和注解在以下两篇文章中我分别详细介绍，在这里我不再详解

jdk1.5-新特性之泛型：http://xiaobing259-163-com.iteye.com/blog/904366
jdk1.5-新特性之注解：http://xiaobing259-163-com.iteye.com/blog/906529

2.增强for循环(for-each)

用Iterator实现如下：
	import java.util.ArrayList;  
	import java.util.Collection;  
	  
	public class GenericTest {  
	    public static void main(String[] args) {  
	        Collection c = new ArrayList(); 
                c.add("aa");  
	        c.add("bb"); 
               for(Iterator i=c.iterator(); i.hasNext();){
                  String s= (String)i.next();
                    System.out.println(s);  
                 }
	    }  
	}  
	运行结果：  
	aa  
	bb  

用for-each更简单：

	import java.util.ArrayList;  
	import java.util.Collection;  
	  
	public class GenericTest {  
	    public static void main(String[] args) {  
	        Collection<String> c = new ArrayList<String>();  
                c.add("aa");  
	        c.add("bb");  
                for(String s:c){  
	            System.out.println(s);  
	        }  
	    }  
	}  
	运行结果：  
	aa  
	bb  

3.自动装箱拆箱(Autoboxing/unboxing)

例3-1代码
自动装箱拆箱大大方便了基本类型数据和它们封装类地使用。
  自动装箱：基本类型自动转为封装类.(int >> Integer)
  自动拆箱：封装类自动转为基本类型.(Integer >> int)

  在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀，
  现在自动转换机制解决了我 们的问题。
  int a = 3;
  Collection c = new ArrayList();
  c.add(a);//自动转换（装箱）成Integer.

  Integer b = new Integer(2);
  c.add(b + 2);
  这里Integer先自动转换（拆箱）为int进行加法运算，然后int再次转换（装箱）为Integer.

     public class T {  
       
         public static void main(String[] args) {  
             Integer i1 = 128;  
             Integer i2 = 128;  
             int i3 = 128;  
             int i4 = 128;  
             Integer i5 = 127;  
             Integer i6 = 127;  
              
            Long long1 = 128L;  
            Long long2 = 128L;  
            long long3 = 128L;  
            long long4 = 128L;  
           long long5 = -128L;  
            long long6 = -128L;  
              
           //-128 ~ 127之间数值装箱时会共享内存副本, 超过这个范围，则不会共享引用，即对象地址将不同  
              
            System.out.println(i1 == i2); //实质是比较两个不同引用 false  
           System.out.println(i5 == i6); //实质是比较两个相同（共享）引用true  
           System.out.println(i1 == i3); //先将i1拆箱，然后比较基本类型 true  
           System.out.println(i1.equals(i4)); //先将i4装箱，然后比较基本类型 true  
             
           System.out.println(long1 == long2);//两个引用不同 false  
           System.out.println(long5 == long6);//共用副本 true  
           System.out.println(long1 == long3);//long1先拆箱， 在比较 true  
            System.out.println(long2.equals(long4));//long4先装箱, 再equals, true  
        }  
    }  

4.静态导入(static import)

      要使用用静态成员（方法和变量）我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可调用，使用这些静态成员无需再给出他们的类名。

	//静态导入Math的所有方法  
	import static java.lang.Math.*;  
	  
	public class StaticImportTest {  
	    public static void main(String[] args){  
	        //类中生成随机数数可以直接使用静态引入的random方法了，而不用Math.random()这样调用了  
	        System.out.println(random());  
又：
                System.out.println(max(3, 6));//无需写Math.max();
                 r = sin(PI * 2); //无需再写r = Math.sin(Math.PI); 
	    }  
	}  

5.格式化打印(formatted print)

C语言中printf()风格的格式化输出。
这里只举一个thinking in java的一个例子：
例5-1代码

	public class SimpleFormat {  
	    public static void main(String[] args) {  
	        int x = 5;  
	        double y = 5.332542;  
	        //The old way  
	        System.out.println("Row 1: ["+x+" "+y+"]");  
	        //The new way  
	        System.out.format("Row 1: [%d %f]\n", x,y);  
	        //or  
	        System.out.printf("Row 1: [%d %f]\n", x, y);  
	    }  
	}  
	  
	运行结果：  
	Row 1: [5 5.332542]  
	Row 1: [5 5.332542]  
	Row 1: [5 5.332542]  
 

可以看到，format和printf是等价的，他们只需要一个简单的格式化字符串，加上一串参数即可，每个参数对应一个格式修饰符

6.枚举(Enums)

  JDK1.5加入了一个全新类型的“类”－枚举类型。为此JDK1.5引入了一个新关键字enmu. 我们可以这样来定义一个枚举类型。
当每一类型可取值范围是有限的时候，可以使用枚举，例如每个学生登记只能用ABCD表示，如果直接用E的话，那么编译不会出错，但是却不符合输入要求，而使用枚举增加程序的易读性和健壮性？
Java代码

public class GradeTest {  
       public static void main(String[] args) {  
        Student stu = new Student();  
        stu.setName("wasw100");  
        stu.setGrade(Grade.A);  
        //输出学生信息  
        System.out.println(stu);  
    }  
}  
	  
	/** 
	 * 枚举：Grader 学生考试等级 
	 * @author wasw100 
	 */  
	enum Grade{  
	    A,B,C,D  
	}  
	  
	class Student {  
	    private String name;  
	    private Grade grade;  
	      
	    //重写toString()方法  
	    public String toString(){  
	        return "name:+"+name+"\ngrader:"+grade;  
	    }  
	  
	    public String getName() {  
	        return name;  
	    }  
	  
	    public void setName(String name) {  
	        this.name = name;  
	    }  
	  
	    public Grade getGrade() {  
	        return grade;  
	    }  
	  
	    public void setGrade(Grade grade) {  
	        this.grade = grade;  
	    }  
	  
	}  

7.可变长参数(varargs)

可变参数使程序员可以声明一个接受可变数目参数的方法。
注意，可变参数必须是函数声明中的最后一个参数。
假设我们要写一个简单的方法打印一些对象,在jdk1.5以前我们需要重载多个方法

util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);
…

  在JDK1.5之前，我们可以用重载来实现，但是这样就需要写很多的重载函数，显得不是很有效。如果使用可变参数的话我们只需要一个函数就行了

public void write(Object... objs) {
   for (Object obj: objs)
      System.out.println(obj);
}
下面是网上一个 唐僧 给 悟空 将佛经的例子
Java代码

	public class VarargsTest {  
	    public void speak(String name, Object... arguments) {  
	        System.out.print(name+": ");  
	        for (Object object : arguments) {  
	            System.out.print(object);  
	        }  
	        System.out.println();  
	    }  
  
	    public static void main(String[] args) {  
	        VarargsTest vt = new VarargsTest();  
	        vt.speak("悟空", "人和妖精都是妈生的,");  
	        vt.speak("悟空", "不同的人是人他妈生的,", "妖是妖他妈生的,");  
	    }  
	}  
	  
	运行结果：  
	悟空: 人和妖精都是妈生的,  
	悟空: 不同的是，人是人他妈生的,妖是妖他妈生的,