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

一时失言乱红尘 2022-07-24 12:19 260阅读 0赞

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);
    	 }
    	 }
    }