JAVA的泛型 && JAVA的几种for循环方式

         泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符。

        在没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。 泛型的好处是在编译的时候检查类型安全，并且所有的转换都是隐式的。

（1）泛型的规则

A，泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。 　　

B，同一种泛型可以对应多个版本（因为参数类型是不确定的）。

C，泛型的类型参数可以有多个。

（2）两个实例。前者没用泛型，后者有用泛型

class Gen2{
	private Object ob;   //用Object实现参数类型任意化
	public Gen2(Object ob){
		this.ob = ob;
	}
	
	public Object getOb(){
		return ob;
	}
	
	public void setOb(Object ob){
		this.ob = ob;
	}
	
	public void showType(){
		System.out.println("T real type:"+ob.getClass().getName());  //输出参数类型的类型名字      	        }
}

public class TestNew {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Gen2 intOb = new Gen2(new Integer(88));	
		intOb.showType();
 		int i = (Integer)intOb.getOb();		
       		System.out.println("value = "+i);
   		System.out.println("--------------------------");
		
		Gen2 strOb = new Gen2("hello gen!");	
		strOb.showType();
		String s = (String)strOb.getOb();
		System.out.println("value = "+s);
	}
}    

运行结果是：

T real type:java.lang.Integer
value = 88
--------------------------
T real type:java.lang.String
value = hello gen!
         下面程序的运行结果也是上面一样。

class Gen<T>{			//泛型数据类型T
	private T ob;    //数据类型做参数
	public Gen(T ob){
		this.ob = ob;
	}
	
	public T getOb(){
		return ob;
	}
	
	public void setOb(T ob){
		this.ob = ob;
	}
	
	public void showType(){
		System.out.println("T real type:"+ob.getClass().getName());
	}
}

public class TestNew {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Gen<Integer> intOb = new Gen<Integer>(88);	//不用知道预先要转化的类型，两边一致就行
		intOb.showType();
		int i = intOb.getOb();
		System.out.println("value = "+i);
		System.out.println("--------------------------");
		
		Gen<String> strOb = new Gen<String>("hello gen!");
		strOb.showType();
		String s = strOb.getOb();
		System.out.println("value = "+s);
	}
}

=============================================================================================

        在Java程序中，要“逐一处理”――或者说，“遍历”――某一个数组或Collection中的元素的时候，一般会使用一个for循环来实现。
 （1）遍历数组的传统方式

		int[] integers = {1,2,3,4};
		for(int j=0;j<integers.length;j++){
			int i = integers[j];
			System.out.println(i);

（2）iterator方式

import java.util.Collection;
import java.util.Iterator;

public class TestNew {	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/* 建立一个Collection */
		String[] strings = {"A", "B","C","D"};
		Collection stringList = java.util.Arrays.asList(strings);
  		/* 开始遍历 */
		for (Iterator itr = stringList.iterator(); itr.hasNext();) {
		    Object str = itr.next();
		    System.out.println(str);
		}
	}
}

或者

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class main {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		
		list.add(new Integer(6));
		list.add(new Integer(9));
		list.add(new Integer(3));
		list.add(new Integer(5)); 
		list.add(new Integer(6));
		
		Iterator<Integer> it = list.iterator(); 
		
		while(it.hasNext()){      
			System.out.println(it.next());    
		} 
	}
}

List(列表)集合中的对象按照索引的位置排序，可以有重复的对象，允许按照对象在集合中的索引位置检索对象，List与数组有些相似。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map  <String,String>  map  =  new  HashMap<String,String>();   
		map.put("1", "星期一");   
		map.put("2", "星期二");   
		map.put("3", "星期三");   
		map.put("4", "星期四");   
		map.put("5", "星期五");   
		map.put("6", "星期六"); 
		map.put("7", "星期日");   
		Set<String> keys = map.keySet();   
		Iterator<String> it = keys.iterator();   
		while(it.hasNext())
		{    
			String key = it.next();    
			String value =map.get(key);    
			System.out.println(key+" "+value);   
		}
	}
}

Map(映射)：集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。结果是

2 星期二
1 星期一
7 星期日
6 星期六
5 星期五
4 星期四

（3）而在Java语言的J2SE 1.5版本之后，引入了另一种形式的for循环。借助这种形式的for循环，现在可以用一种更简单地方式来进行遍历的工作。Java的第二种for循环基本是这样的格式： for (循环变量类型 循环变量名称 : 要被遍历的对象)  循环体

        借助这种语法，遍历一个数组的操作就可以采取这样的写法：

	public static void main(String[] args) {
		int[] integers = {4,5,6,7};

		for (int i : integers) {
		     System.out.println(i); 
		 }
	}

这里所用的for循环，会在编译期间被看成是这样的形式：

for (int 变量名甲 = 0; 变量名甲 < integers.length; 变量名甲++) {
     System.out.println(integers[变量名甲]); 
 }

（4）对应的，而遍历一个Collection的操作也有简单写法，不详说

 

参考原文：http://baike.baidu.com/view/1436058.htm

参考原文：http://www.jb51.net/article/35884.htm

参考原文：http://blog.csdn.net/sun_abc/article/details/5906765