黑马程序员——高新技术--jdk1.5新特性

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

八、jdk1.5新特性

1. 高级for（ForEach）

import java.util.*;
/*
高级for循环

格式：
for（数据类型 变量名：被遍历的集合或者数组）
{

}
对集合进行遍历，只能获取元素，但不能对集合进行操作
迭代器除了遍历还可以进行remove集合中元素的动作
如果使用ListIterator，还可以在便利过程中对集合进行增删改查的动作

传统for和高级for有什么区别呢？
高级for有一个局限性，必须有被遍历的目标
建议在遍历数组的时候使用传统for，传统for可以定义角标


*/
class ForEachDemo 
{
	public static void main(String[] args) 
	{
		ArrayList list = new ArrayList();
		list.add("abc01");
		list.add("abc02");
		list.add("abc03");

		Iterator it = list.iterator();

		while (it.hasNext())
		{
			System.out.println(it.next());
		}

		for (String s1:list )
		{
			System.out.println(s1);
		}
		int[] arr = {3,5,1};
		for (int i : arr)
		{
			System.out.println(i);
		}

		HashMap hm = new HashMap();
		hm.put(1,"abtc");
		hm.put(2,"absc");
		hm.put(3,"adbc");
		hm.put(4,"abfc");

		Iterator it1 = hm.keySet().iterator();
		while (it1.hasNext())
		{
			Integer i = (Integer)it1.next();
			System.out.println(i+"...."+hm.get(i));
		}

		for (Integer i : hm.keySet() )
		{
			System.out.println(i+"....."+hm.get(i));
		}

		Set> en = hm.entrySet();
		for(Map.Entry me : en)
		{
			System.out.println(me.getKey()+"....."+me.getValue());
		}

	}
}

2. 可变参数

JDk1.5出现的新特性

可变参数其实就是上一种数组参数的简写形式，不用每一次都手动的建立数组对象。

只要将要操作的元素作为参数传递即可

隐式将这些参数封装成了数组

在使用时注意，可变参数一定要定义在参数列表的最后面

class  ParamMethodDemo
{
	public static void main(String[] args) 
	{
		show(2,3,4);
	}

	public static void show(int...arr)
	{
		System.out.println(arr);
	}

/*	public static void show(int[] arr)
	{
		
	}

	public void show(int a,int b)
	{
		System.out.println(a+","+b);
	}
	public void show(int a,int b,int c)
	{
	
	}
	*/
}

3. 静态导入

通过使用 import static，就可以不用指定 Constants 类名而直接使用静态成员，包括静态方法。

import xxxx 和 import static xxxx的区别是前者一般导入的是类文件如import java.util.Scanner;后者一般是导入静态的方法，import static java.lang.System.out。

 

/*
StaticImport  静态导入
当类名重名时，需要指定具体的包名。
当方法重名时，指定具备所属的对象或者类。
*/

import static java.lang.System.*;
import java.util.*;
import static java.util.Arrays.*;  //导入的是Arrays这个类中的所有静态成员
class  StaticImport
{
	public static void main(String[] args) 
	{
		int[] arr = {3,1,5};
		//Arrays.sort(arr);
		sort(arr);
		//int index = Arrays.binarySearch(arr,1);
		int index = binarySearch(arr,1);

		out.println(Arrays.toString());
	}
}

4. 泛型

C++ 通过模板技术可以指定集合的元素类型，而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也 不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。

泛型：jdk1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制。

好处：
1.将运行时期出现问题ClassCastException，转移到了编译时期
 方便程序员解决问题，让运行时期问题减少，安全。
2.避免了强制转换的麻烦

泛型格式：通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型
其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

import java.util.*;
class  GenericDemo
{
	public static void main(String[] args) 
	{
		ArrayList a1 = new ArrayList();

		a1.add("abc01");
		a1.add("abc0991");
		a1.add("abc014");
		

		Iterator it = a1.iterator();
		while(it.hasNext())
		{
			String s = (String)it.next();
			System.out.println(s.length());
		}
	}
}

 

import java.util.*;

class GenericDemo2 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new LenComparator());
		ts.add("abcd");
		ts.add("abcde");
		ts.add("abcdef");
		ts.add("abcdefth");
		Iterator it = ts.iterator();
		while(it.hasNext())
		{	String s = it.next();
			System.out.println(s);
		}

	}
}

class LenComparator implements Comparator
{
	public int compare(String o1,String o2)
	{
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if(num==0)
			return o1.compareTo(o2);
		return num;

	
	}
}

 

//泛型定义在接口上

interface Inter

{
	void show(T t);
}

/*
class InterImpl implements Inter

{
	public void show(String t)
	{
		System.out.println("show:"+t);
	}
}
*/
class InterImpl implements Inter
{
	public void show(T t)
	{
		System.out.println("show:"+t);
	}
}

class  GenericDemo5
{
	public static void main(String[] args) 
	{
		//InterImpl i = new InterImpl();
		//i.show("haha");
		InterImpl i = new InterImpl();
		i.show(4);
	}
}

 

import java.util.*;

/*
	? 通配符，也可以理解为占位符。
	泛型的限定：
	？ extends E：可以接受E类型或者E的子类型，上限限定
	？ super E：可以接受E类型或者E的父类型，下限限定

*/
class GenericDemo6 
{
	public static void main(String[] args) 
	{
		ArrayList a1 = new ArrayList();
		a1.add("abcd1");
		a1.add("abcd2");
		a1.add("abcd3");
		ArrayList a2 = new ArrayList();
		a2.add(4);
		a2.add(7);
		a2.add(1);
		printColl(a1);
		printColl(a2);
		 
	}
	public static void printColl(ArrayList a1)
	{
		Iterator it = a1.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

5. 内省（Introspector）

是 Java语言对Bean类属性、事件的一种缺省处理方法。例如类A中有属性name,那我们可以通过getName,setName来得到其值或者设置新 的值。通过getName/setName来访问name属性，这就是默认的规则。Java中提供了一套API用来访问某个属性的getter /setter方法，通过这些API可以使你不需要了解这个规则（但你最好还是要搞清楚），这些API存放于包java.beans中。

一 般的做法是通过类Introspector来获取某个对象的BeanInfo信息，然后通过BeanInfo来获取属性的描述器 （PropertyDescriptor），通过这个属性描述器就可以获取某个属性对应的getter/setter方法，然后我们就可以通过反射机制来 调用这些方法。

6. 自动装箱与拆箱

自动装箱的过程：每当需要一种类型的对象时，这种基本类型就自动地封装到与它相同类型的包装中。

自动拆箱的过程：每当需要一个值时，被装箱对象中的值就被自动地提取出来，没必要再去调用intValue()和doubleValue()方法。

自动装箱，只需将该值赋给一个类型包装器引用，java会自动创建一个对象。

自动拆箱，只需将该对象值赋给一个基本类型即可。

java——类的包装器

类型包装器有：Double,Float,Long,Integer,Short,Character和Boolean

7. 枚举

把集合里的对象元素一个一个提取出来。枚举类型使代码更具可读性，理解清晰，易于维护。枚举类型是强类型的，从而保证了系统安全性。而以类的静态字段实现的类似替代模型，不具有枚举的简单性和类型安全性。

简单的用法：JavaEnum简单的用法一般用于代表一组常用常量，可用来代表一类相同类型的常量值。

复杂用法：Java为枚举类型提供了一些内置的方法，同时枚举常量还可以有自己的方法。可以很方便的遍历枚举对象。

在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。

例如星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。

在java中如何更好的使用这些“数据集”呢？因此枚举便派上了用场，以下代码详细介绍了枚举的用法。

 

/**
 * 枚举用法详解
 */
public class TestEnum {
    /**
     * 普通枚举
     */
    public enum ColorEnum {
        red, green, yellow, blue;
    }
    
    /**
     * 枚举像普通的类一样可以添加属性和方法，可以为它添加静态和非静态的属性或方法
     */
    public enum SeasonEnum {
        //注：枚举写在最前面，否则编译出错
        spring, summer, autumn, winter;

        private final static String position = "test";

        public static SeasonEnum getSeason() {
            if ("test".equals(position))
                return spring;
            else
                return winter;
        }
    }
    
    /**
     * 性别
     * 
     * 实现带有构造器的枚举
     */
    public enum Gender{
        //通过括号赋值,而且必须带有一个参构造器和一个属性跟方法，否则编译出错
        //赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值；如果不赋值则不能写构造器，赋值编译也出错
        MAN("MAN"), WOMEN("WOMEN");
        
        private final String value;

        //构造器默认也只能是private, 从而保证构造函数只能在内部使用
        Gender(String value) {
            this.value = value;
        }
        
        public String getValue() {
            return value;
        }
    }
    
   /**
    * 订单状态
    * 
    * 实现带有抽象方法的枚举
    */
    public enum OrderState {
        /** 已取消 */
        CANCEL {public String getName(){return "已取消";}},
        /** 待审核 */
        WAITCONFIRM {public String getName(){return "待审核";}},
        /** 等待付款 */
        WAITPAYMENT {public String getName(){return "等待付款";}},
        /** 正在配货 */
        ADMEASUREPRODUCT {public String getName(){return "正在配货";}},
        /** 等待发货 */
        WAITDELIVER {public String getName(){return "等待发货";}},
        /** 已发货 */
        DELIVERED {public String getName(){return "已发货";}},
        /** 已收货 */
        RECEIVED {public String getName(){return "已收货";}};
        
        public abstract String getName();
    }
    
    public static void main(String[] args) {
        //枚举是一种类型，用于定义变量，以限制变量的赋值；赋值时通过“枚举名.值”取得枚举中的值
        ColorEnum colorEnum = ColorEnum.blue;
        switch (colorEnum) {
        case red:
            System.out.println("color is red");
            break;
        case green:
            System.out.println("color is green");
            break;
        case yellow:
            System.out.println("color is yellow");
            break;
        case blue:
            System.out.println("color is blue");
            break;
        }
        
        //遍历枚举
        System.out.println("遍历ColorEnum枚举中的值");
        for(ColorEnum color : ColorEnum.values()){
            System.out.println(color);
        }
        
        //获取枚举的个数
        System.out.println("ColorEnum枚举中的值有"+ColorEnum.values().length+"个");
        
        //获取枚举的索引位置，默认从0开始
        System.out.println(ColorEnum.red.ordinal());//0
        System.out.println(ColorEnum.green.ordinal());//1
        System.out.println(ColorEnum.yellow.ordinal());//2
        System.out.println(ColorEnum.blue.ordinal());//3
        
        //枚举默认实现了java.lang.Comparable接口
        System.out.println(ColorEnum.red.compareTo(ColorEnum.green));//-1
        
        //--------------------------
        System.out.println("===========");
        System.err.println("季节为" + SeasonEnum.getSeason());
        
        
        //--------------
        System.out.println("===========");
        for(Gender gender : Gender.values()){
            System.out.println(gender.value);
        }
       
        //--------------
        System.out.println("===========");
        for(OrderState order : OrderState.values()){
            System.out.println(order.getName());
        }
    }
    
}