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