容器一（集合）

 容器的泛型

泛型的本质就是“数据类型的参数化”。 我们可以把“泛型”理解为数据类型的一个占位符(形式参数)，即告诉编译器，在调用泛型时必须传入实际类型。

好处：增强程序的可读性和安全性

package cn.xjion.pro09;

import java.util.ArrayList;

public class TestGenericity {
	public static void main(String[] args) {
		//在创建集合对象时，明确集合中所存储的元素的类型
//		定义一个String类型的容器
		ArrayList<String> al = new ArrayList<String>();
//		只能存储String类型的数据
		al.add("hello");
//		al.add(123);报错
//		打印内容
		for (String str:al) {
			System.out.println(str);
		}
	}
}

泛型分类

泛型类

package cn.xjion.pro09;

public class MyGenericity<T> {
//T就是一个英文字母，指代泛型，代表一种数据类型
//	声明T类型的变量t
	private T t;
//get,set 方法
	public T getT() {
		return t;
	}

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

	public static void main(String[] args) {
//		是什么类型就传什么类型
		MyGenericity<String> my1 = new MyGenericity<String>();
		MyGenericity<Integer> my2 = new MyGenericity<Integer>();
//		对相应的类型添加相应的数据
		my1.setT("hello");
		my2.setT(123);
		System.out.println(my1.getT());
		System.out.println(my2.getT());
	}
}

泛型接口

package cn.xjion.pro09;

public interface MyInterface<T> {

}
//实现接口
class MyImplement implements MyInterface<String>{
	
}
class MyImplement1<T> implements MyInterface<T>{
	
}
class TestMyInterface{
	public static void main(String[] args) {
		MyImplement mi = new MyImplement();
		MyImplement1<Integer> mi2 = new MyImplement1<Integer>();
	}
}

泛型方法

package cn.xjion.pro09;
public class MyMethod<T> {//泛型类
	public void show(T t) { //在创建MyMethod类的对象时决定
		System.out.println(t);
	}
	public <Q> void method(Q q) { //在调用method这个方法时明确
		System.out.println(q);
	}
	public <K> void fun(K...k) { //可变参数的泛型方法
		for(Object obj:k) {
			System.out.println(obj);
		}
	}
}

package cn.xjion.pro09;
public class TestMyMethod {
	public static void main(String[] args) {
		MyMethod<String> my = new MyMethod<String>();
		my.show("hello"); //在创建类的对象时明确了数据类型为String
		
		//有了泛型方法，解决了参数个数相同的情况下的方法重载
		my.method("hello");
		my.method(123);
		my.method('a');
		
		//可变参数的泛型方法，解决参数的个数不同，类型不同的方法重载
		my.fun("hello");
		my.fun("hello","world","java");
		my.fun(123,456);
	}
}

泛型的高级使用_容器中

泛型的上限：使用关键字extends,表示参数化的类型可能是所指定的类型或者是此类型的子类
泛型的下限：使用关键字super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object类

Studnet类

package cn.xjion.pro03;

import cn.xjion.pro09.Person;

public class Student extends Person{
	
	//属性field
	int id;
	String name;
	int age;
//	空构造器
	public Student(){
		
	}
	
//重写toString
@Override
public String toString() {
	return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}
//构造器
public Student(int id, String name, int age) {
	super();
	this.id = id;
	this.name = name;
	this.age = age;
}
}

Person类

package cn.xjion.pro09;
//	Person类实现Person型的Comperable接口
public class Person implements Comparable<Person>{
//	属性
	private String name;
	private int age;
//	get，set方法
	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;
	}
//	带参构造方法
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
//空构造器
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
//	重写hashCode和equals方法
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
//	重写toString
@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	//	重写compareTo方法
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		return 0;
	}
}

实现

package cn.xjion.pro09;

import java.util.ArrayList;

import cn.xjion.pro03.Student;


public class TestGener {
	public static void main(String[] args) {
//		创建集合对象，同时明确了对象只能是Person类型
		ArrayList<Person> a1 = new ArrayList<Person>();
		Person p1 = new Person("xjion",20);
		Person p2 = new Person("sarry",25);
		Person p3 = new Person("jack",18);
//		添加到集合中
		a1.add(p1);
		a1.add(p2);
		a1.add(p3);
//		需要遍历集合
		print(a1);
		
//		创建集合对象，同时明确了对象只能是Student类型
		ArrayList<Student> al2 = new ArrayList<Student>();
		Student stu1 = new Student(1001,"merny",20);
		Student stu2 = new Student(2112,"anico",18);
//		添加到集合
		al2.add(stu1);
		al2.add(stu2);
//		打印
		print(al2);
		
//		调用show方法
		System.out.println("-------------------------");
		show(a1);
		show(al2);
		ArrayList<Object> alObject = new ArrayList<Object>();
		Object ob1 = new Object();
		Object obj2 = new Object();
		alObject.add(ob1);
		alObject.add(obj2);
		
		show(alObject);
		
		
	}
//	Person及Person的子类的打印遍历
	public static void print(ArrayList<? extends Person> al){
		for (Person person : al) {
			System.out.println(person);
		}
	}
	public static void show(ArrayList<? super Student> al){
		for (Object object : al) {
			System.out.println(object);
		}
	}
	
}

package cn.xjion.pro09;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.TreeMap;
import java.util.TreeSet;

public class Test2 {
	public static void main(String[] args) {
		
		ArrayList<String> al = new ArrayList<String>();
		al.add("hello");
		
		LinkedList<Integer> linkedList = new LinkedList<Integer>();
		linkedList.add(123);
		
		//存储自定义对象时，要求Person类重写hashCode()及equals()方法
		HashSet<Person> hs = new HashSet<Person>();
		
		//Person对象具备比较规则，可以是内部比较器，也可以是外部比较器
		TreeSet<Person> treeSet = new TreeSet<Person>();
		
		HashMap<String,Integer> hm = new HashMap<String,Integer>();
		hm.put("hello", 123);
		
		HashMap<Person,String> hm2 = new HashMap<Person,String>();
		Person p1 = new Person("marry",20);
		hm2.put(p1, p1.getName());
		
		TreeMap<Person,Integer> tm = new TreeMap<Person,Integer>();
		tm.put(p1, p1.getAge());
		
		//泛型只在编译期间起作用
	}
}

这里面的东西等把容器看完了就彻底明白了！有不对的地方望大家指出噢^_^!