JavaSe——集合_Part2

A.泛型

package com.core.collection.demo;

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

/*
 * ArrayList存储字符串并遍历
 * 
 * 我们按照正常的写法来写这个程序， 结果确出错了。
 * 为什么呢?
 * 		因为我们开始存储的时候，存储了String和Integer两种类型的数据。
 * 		而在遍历的时候，我们把它们都当作String类型处理的，做了转换，所以就报错了。
 * 但是呢，它在编译期间却没有告诉我们。
 * 所以，我就觉得这个设计的不好。
 * 回想一下，我们的数组
 * 		String[] strArray = new String[3];
 * 		strArray[0] = "hello";
 * 		strArray[1] = "world";
 * 		strArray[2] = 10;
 * 集合也模仿着数组的这种做法，在创建对象的时候明确元素的数据类型。这样就不会在有问题了。
 * 而这种技术被称为：泛型。
 * 
 * 泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。
 * 格式：
 * 		<数据类型>
 * 		此处的数据类型只能是引用类型。
 * 好处：
 * 		A:把运行时期的问题提前到了编译期间
 * 		B:避免了强制类型转换
 * 		C:优化了程序设计，解决了黄色警告线
 */

public class Test {

	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add("hello");
		list.add("world");
		list.add("java");
		// list.add(10); 加了泛型之后，编译不通过

		// 遍历list输出数据
		// A.toArray转成数组-这个方法还是要强转的，因为他用的是父类Collection的toArray方法
		Object[] array = list.toArray();
		for (int i = 0; i < array.length; i++) {
			String next = (String) array[i];
			System.out.println(next);
		}

		// B.使用特有方法size和get-注意这个方法不需要强转
		for (int i = 0; i < list.size(); i++) {
			String s = list.get(i);
			System.out.println(s);
		}

		// C.使用得迭代器-注意这个方法不需要强转
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			String s = iterator.next();
			System.out.println(s);
		}
		// D.使用for循环改进，提高效率
		System.out.println("========");
		for (Iterator it2 = list.iterator(); it2.hasNext();) {
			String s = it2.next();
			System.out.println(s);
		}
	}

}

1：泛型是一种特殊的类型，它把指定类型的工作推迟到客户端代码声明并实例化类或方法的时候进行。

   也被称为参数化类型，可以把类型当作参数一样传递过来，在传递过来之前我不明确，但是在使用的时候我就用明确了。

2：泛型的好处

A:提高了程序的安全性

B:将运行期遇到的问题转移到了编译期

C:省去了类型强转的麻烦

B.泛型类

l  泛型类

•    把泛型定义在类上

•    格式:public class 类名<泛型类型1,…>

•    注意:泛型类型必须是引用类型

泛型类：

package com.core.collection.demo1;

public class ObjectTool  {

	private T t;
	public void setObj(T t){
		this.t = t;
	}
	
	public T getObj(){
		return t;
	}
}

测试类：

package com.core.collection.demo1;


public class Test {

	//演示泛型类：泛型定义在类上
	public static void main(String[] args) {
		ObjectTool tool = new ObjectTool();
		tool.setObj("hello");
		String s = tool.getObj();
		System.out.println(s);
//		tool.setObj(new Student("张三",20)); 编译报错
		
		ObjectTool tool2 = new ObjectTool();
//		tool2.setObj("world"); 编译报错
		tool2.setObj(new Student("张三",20));
		Student ss = tool2.getObj();
		System.out.println(ss.getName()+"--"+ss.getAge());
	
	}

}

C.泛型方法

l  泛型方法

•    把泛型定义在方法上

•    格式:public<泛型类型> 返回类型方法名(泛型类型.)

注意泛型方法和泛型类的区别。演示输出整型、字符串、布尔型数据的例子：

先用泛型类演示：

package com.core.collection.demo2;

public class ObjectTool {

	public void print(T t) {
		System.out.println(t);
	}
}

测试类：

package com.core.collection.demo2;

public class Test {

	public static void main(String[] args) {
		// 输出整型
		ObjectTool tool = new ObjectTool();
		// tool.print("abc"); 编译报错
		tool.print(10);

		// 输出字符串
		ObjectTool tool2 = new ObjectTool();
		// tool2.print(10);//编译报错
		tool2.print("abc");
		
//		输出布尔值
		ObjectTool tool3 = new ObjectTool();
		tool3.print(true);

	}

}

再用泛型方法：

package com.core.collection.demo2;

public class ObjectTool2 {

	public  void print(T t) {
		System.out.println(t);
	}
}

测试类：

package com.core.collection.demo2;

public class Test {

	public static void main(String[] args) {
		// 输出整型
		ObjectTool tool = new ObjectTool();
		// tool.print("abc"); 编译报错
		tool.print(10);

		// 输出字符串
		ObjectTool tool2 = new ObjectTool();
		// tool2.print(10);//编译报错
		tool2.print("abc");
		
//		输出布尔值
		ObjectTool tool3 = new ObjectTool();
		tool3.print(true);
		
		System.out.println("----使用泛型方法-----");
		ObjectTool2 tool4 = new ObjectTool2();
		tool4.print("hello");
		tool4.print(2015);
		tool4.print(true);
		

	}

}

D.泛型接口

l  泛型接口

•    把泛型定义在接口上

•    格式:public  interface 接口名<泛型类型1…>

接口定义：

package com.core.collection.demo3;

public interface Inter {
	public abstract void print(T t);

}

第一种实现：

package com.core.collection.demo3;

//实现类在实现接口的时候，有两种情况，
//第一种，已经知道该类型是什么了。但这种情况不常见
public class InterImpl implements Inter {

	@Override
	public void print(String t) {
		System.out.println(t);
	}

}

第二种接口实现（不知道该类型是什么）

package com.core.collection.demo3;

//第二种情况，还不知道该类型是什么
public class InterImpl2 implements Inter {

	@Override
	public void print(T t) {
		System.out.println(t);
	}

}

测试类：

package com.core.collection.demo3;

public class Test {

	public static void main(String[] args) {
		// 第一种类型测试
		InterImpl impl = new InterImpl();
		impl.print("hello");
		// impl.print(123); 编译报错
		// 这种情况不常见
		
		//第二种情况测试
		InterImpl2 impl2 = new InterImpl2();
		impl2.print("world");
		
		InterImpl2 impl3 = new InterImpl2();
		impl3.print(123);
	}

}

D.泛型通配符

l  泛型通配符

•    任意类型，如果没有明确，那么就是Object以及任意的Java类了

l  ? extends E

•    向下限定，E及其子类

l  ? super E

•    向上限定，E及其父类

package com.core.collection.demo4;

import java.util.ArrayList;

public class Test {

	public static void main(String[] args) {
		// 如果给出，则必须一致
		ArrayList list1 = new ArrayList();
		// ArrayList list2 = new ArrayList(); 编译报错
		// ArrayList list3 = new ArrayList();编译报错
		// ArrayList list4 = new ArrayList();编译报错
		// ArrayList list4 = new ArrayList();编译报错

		// ? 表示任意类型都可
		ArrayList list5 = new ArrayList();
		ArrayList list6 = new ArrayList();
		ArrayList list7 = new ArrayList();
		ArrayList list8 = new ArrayList();
		ArrayList list9 = new ArrayList