Java_泛型集合的定义及使用

泛型集合的定义及使用

引入

什么是泛型、为什么要引入泛型、泛型类和泛型方法的使用

实例泛型：

​ 创建对象时，为类所定义的泛型，进行参数化赋值。

• 类：创建对象时，为类所定义的泛型，进行参数化赋值
• 接口：实现接口时，为接口所定义的泛型，进行参数化赋值

静态泛型：

• 定义在方法的返回值类型前面：、、<T extends Comparable>、<T extends Comparable<? super T>> 可应用在形参列表、返回值两种场景上，不单单可以规范泛型，还可以语义化返回值。
• 定义在方法的形参列表当中：<?>、<? extends Object>、<? super Integer>，不支持使用& 只能应用在形参列表上，规范泛型。

1 概述

          一种约束—规范类型（常用名字：E = Elememt、T = Type、K = Key、V = Value），将类型的明确工作提前到对象的创建以及方法调用,防止程序不安全泛型 :将类型的明确工作提前到对象的创建以及方法调用,防止程序不安全；参数化类型、类型安全的集合，强制集合的类型必须一致;

特点：

1. 编译时即可检查，而非运行时抛出异常
2. 访问时，不必类型转换也就是拆箱
3. 不同泛型之间引用不能相互赋值，泛型不存在多态。（左泛型不可为右父类）

2 泛型的好处

1. 将运行时期异常提前到了编译时期；
2. 在遍历集合时，避免了强制类型转换；
3. 解决了程序黄色警告线的问题------>提高了程序的安全性；

public static void main(String[] args) {
		//创建一个ArrayList集合对象
		ArrayList<String> array = new ArrayList<String>() ;//后面:泛型推断
		
		//添加元素
		array.add("kaka") ;
		array.add("hello") ;
		array.add("java") ;
		array.add("javaee") ;
		
		//遍历
		Iterator<String> it = array.iterator() ;
		while(it.hasNext()) {
			String s = it.next() ;
			System.out.println(s);
		}
	}

• 使用泛型集合时注意类型要保持一致，否则会出现类型转化异常（ClassCastException）

2.1 ArrayList集合存储自定义对象，加入泛型

需求：使用ArrayList集合存储自定义对象Student，加入泛型

1)定义一个学生类

2)创建集合对象 ArrayList

3)创建5个学生

5)将5个学生添加到集合中

6)创建迭代器

7)利用迭代器遍历集合

8）利用get(int index)+size()相结合的方式遍历

/*
 * 学生类
 */
public class Student {
	private String name ;
	private int age ;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

public static void main(String[] args){
		//创建一个ArrayList集合
		ArrayList<Student> array = new ArrayList<Student>() ;
		
		//创建学生对象
		Student s1 = new Student("曹操",35) ;//后知后觉
		Student s2 = new Student("蒋干",25) ;//不知不觉
		Student s3 = new Student("诸葛亮",30) ;//先知先觉
		
		array.add(s1) ;
		array.add(s2) ;
		array.add(s3) ;
		
		//迭代器
		Iterator<Student> it = array.iterator() ;
		while(it.hasNext()) {
			Student s = it.next() ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		System.out.println("----------------------------");
		
		//普通for循环:get(int index)+size()相结合
		for(int x = 0 ; x < array.size() ; x ++) {
			Student s = array.get(x) ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}

3 泛型的应用

泛型主要应用在集合中：

• 定义在类中
• 定义在接口中
• 定义在方法中

3.1 泛型类

把泛型定义在类上

格式:

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

  泛型类型必须是引用类型

/*
 * 使用泛型:提高程序的安全性:将泛型定义类上
 */
public class ObjectTool<T>{
	//成员变量
	private  T obj ;
	
	//获取功能
	public T get() {
		return obj ;
	}
	
	//设置功能
	public void set(T obj) {
		this.obj = obj ;
	}
}

/*
 * 将泛型定义在类上 	测试类
 */
 public static void main(String[] args) {
			//创建ObjectTool类的对象
			ObjectTool<String> ot = new ObjectTool<String>() ;
			
			//设置数据
			ot.set("卡卡"); 
			//获取数据
			String s = ot.get() ;
			System.out.println("姓名是:"+s);
			
			ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;
			
			//设置数据
			ot2.set(28);
			Integer i = ot2.get() ;
			System.out.println("年龄是:"+i);
		}

3.2 泛型方法

把泛型定义在方法上

格式：

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

public class ObjectTool<T>{		
	//将泛型定义在方法上
	public <T> void show(T t) {
		System.out.println(t);
	}
}

public static void main(String[] args) {
		//创建ObjectTool类的对象
		ObjectTool ot = new ObjectTool() ;
		ot.show("hello");
		ot.show(true);
		ot.show(100);
		ot.show(12.34);
	}

3.3 泛型接口

把泛型定义在接口上

格式：

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

3.1 实现类已经明确数据类型

/*
 * 定义在接口上
 */
public interface Inter<T> {
	public abstract void show(T t);
}

/*
 * 测试类
 */
public class InterDemo {
	public static void main(String[] args) {
		//接口多态
		//第一种
		Inter i = new InterImpl();
		i.show("kaka");//kaka
    }
}

/*
 * 接口子实现类
 */
public class InterImpl implements Inter<String>{

	public void show(String t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}
}

3.2 子实现类没有明确数据类型

/*
 * 定义在接口上
 */
public interface Inter<T> {
	public abstract void show(T t);
}

/*
 * 测试类
 */
public class InterDemo {
	public static void main(String[] args) {
		//不明确数据类型
		Inter<Integer> i1 = new InterImpl<Integer>();
		i1.show(100);//100
		Inter<String> i2 = new InterImpl<String>();
		i2.show("kaka");//kaka
    }
}

/*
 * 接口子实现类
 */
public class InterImpl<T> implements Inter<T>{

	@Override
	public void show(T t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}
}

4. 高级泛型_通配符

关于泛型的通配符号：

• <?>：任意Java类型（Object），可以自定义的类型，或者是JDK提供的任意Java类；
• <? extends E>：向下限定E类型以及其他子类；
• <? super E>：向上限定E类型以及其他的父类；

public class Generic{
	public static void main(String[] args) {
		//<?>
		//创建集合类型Collection集合
		Collection<?> c1 = new ArrayList<Object>();
		Collection<?> c2 = new ArrayList<Animal>();
		Collection<?> c3 = new ArrayList<Dog>();
		Collection<?> c4 = new ArrayList<Cat>();
		
		//<? extends E>
		Collection<? extends Animal> c5 = new ArrayList<Animal>();
		Collection<? extends Animal> c6 = new ArrayList<Dog>();
		Collection<? extends Animal> c7 = new ArrayList<Cat>();
//		Collection<? extends Animal> c8 = new ArrayList<Object>();错误
		
		//<? super E>
		Collection<? super Animal> c9 = new ArrayList<Object>();
		Collection<? super Dog> c10 = new ArrayList<Animal>();
		Collection<? super Cat> c11 = new ArrayList<Animal>();
//		Collection<? super Animal> c12 = new ArrayList<Dog>();错误
		
		
	}
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}

• 注：在开发过程中，直接在创建集合的时候给定具体的存储类型
  • Collection<String> c = new ArrayList<String>();