泛型（一）集合中使用泛型

Why

1.解决元素存储的安全性问题

2.解决获取数据元素时，需要类型强转的问题

泛型的使用

1.在集合中使用泛型

2.自定义泛型类、泛型接口、泛型方法

3.泛型与继承的关系

4.通配符

若类A是类B的子类，那么List<A>就不是List<B>的子接口

通配符？

都是?的子类

例如    booleancontainsAll(Collection<?> c);

? Extends E指的是可以放E或者他的子类

boolean addAll(Collection<? extends E> c);

？Super E 指的是E或者其父类

package Generic;

import java.util.List;

import javax.annotation.Generated;

import java.util.ArrayList;

//自定义泛型类
public class Order<T> {
	private String orderName;
	private int orderId;
	private T t;
	List<T> list = new ArrayList<>();

	public void add() {
		list.add(t);
	}

	@Override
	public String toString() {
		return "Order [orderName=" + orderName + ", orderId=" + orderId + ", t=" + t + "]";
	}

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

	public String getOrderName() {
		return orderName;
	}

	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	public int getOrderId() {
		return orderId;
	}

	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}
	//泛型方法
	public <E> E getE(E e){
		return e;
	}
	//实现数组到集合的复制
	public <E> List<E> fromArrayToList(E[] e,List<E> list){
		for(E e1:e){
			list.add(e1);
		}
		return list;
	}

}
//在继承泛型类或泛型接口时，可以指明泛型的类型
class SubOrder extends Order<Integer>{
	
}

package Generic;

import static org.junit.Assert.*;

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

import org.junit.Test;

public class TestGeneric {
	

	// 自定义泛型的使用
	
	@Test
	public void test4() {
		//当实例化泛型的对象时，指明泛型的类型
		//指明以后，对应的类中所欲使用泛型的位置，都变味实例化中指定的泛型类型
		//如果我们自定了泛型类，但是在实例化时候没有使用，那么默认类型是Object类的
		Order<Boolean> order = new Order<>();
		order.setT(true);
		System.out.println("order.getT()="+order.getT());
		System.out.println("order.list="+order.list);

		order.add();
		System.out.println("order.list"+order.list);
		
		SubOrder subOrder=new SubOrder();
		List<Integer> intList=subOrder.list;
		System.out.println(intList);
		
		//当通过对象来调泛型泛型方法时，指明泛型方法的类型
		int i=order.getE(34);
		System.out.println(i);
		Double double1= order.getE(2.3);
		
		//通过泛型方法把数组类型复制到list类型
		Integer[] integers=new Integer[]{1,2,34,4,44};
		List<Integer> list=new ArrayList<>();
		
		
		List<Integer> list2=order.fromArrayToList(integers, list);
		
		Iterator iterator=list2.iterator();
		if(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		//System.out.println(list2);
		
	}

	// 在集合中没有使用泛型的时候
	 @Test
	 public void test1() {
	 List list = new ArrayList();
	 list.add(89);
	 list.add(23);
	 list.add(56);
	 // 1没有添加子类，任何Object及其子类的对象都可以添加进来
	 list.add(new String("AA"));
	
	 for (int i = 0; i < list.size(); i++) {
	 // 2.强转int型时，可能取ClassCastException异常
	 int score = (Integer) list.get(i);
	 System.out.println(score);
	 }
	
	 }
	
	// // 在集合中使用泛型
	 @Test
	 public void test2() {
	 List<Integer> list = new ArrayList<Integer>();
	 list.add(78);
	 // list.add(new String("QQ"));
	 for (int i = 0; i < list.size(); i++) {
	 int score = list.get(i);
	 System.out.println(score);
	 }
	
	 }
	 @Test
	 public void test3(){
	 Map<String, Integer> map=new HashMap<>();
	 map.put("A", 1);
	 map.put("B",2);
	 map.put("c", 3);
	
	 Set<Map.Entry<String, Integer>> set=map.entrySet();
	 for (Map.Entry<String, Integer> s:set){
	 System.out.println(s);
	 }
	 }
}