泛型

泛型：jdk1.5版本之后出现的一种安全机制

泛型的好处？
		1.将运行期的类型转换异常转移到了编译期
		2.避免了强制转换的麻烦

泛型的用处？主要用在集合

什么是泛型？参数化类型，就是将具体的类型参数化

泛型擦除技术？是给编译期使用，用于编译期，确保了类型的安全运行。
运行的时候，.class文件中是没有泛型的，这个就是泛型擦除技术

为什么会有泛型擦除呢?为了兼容运行的类加载器

泛型补偿？在获取集合元素时，不用再做类型强转了。这就是泛型补偿

package com.jp;

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

public class Demo1 {
	public static void main(String[] args) {
		//泛型
		List<String> list = new ArrayList<String>();
		list.add("aa");
		list.add("bb");
		//list.add(new Person("zs", 20));
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String str = it.next();
			System.out.println(str);
		}
	}
}

package com.jp;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

public class Demo2 {
	
	@Test
	public void test1(){
		LinkedList<Person> list = new LinkedList<Person>();
		list.add(new Person("zs",20));
		list.add(new Person("lisi",19));
		list.add(new Person("wangwu",18));
		Iterator<Person> it = list.iterator();
		while(it.hasNext()){
			Person person = it.next();
			System.out.println(person.getName());
		}
	}
	
	@Test
	public void test2(){
		TreeSet<Person> ts = new TreeSet<Person>();
		ts.add(new Person("zs", 20));
		ts.add(new Person("lisi", 19));
		ts.add(new Person("wangwu", 18));
		Iterator<Person> it = ts.iterator();
		while(it.hasNext()){
			Person p = it.next();
			System.out.println(p.getName());
		}
	}
	
	@Test
	public void test3(){
		
		//集合定义的比较器优先
		TreeSet<Person> ts = new TreeSet<Person>(new Comparator<Person>() {

			@Override
			public int compare(Person o1, Person o2) {
				int i = o2.getAge().compareTo(o1.getAge());
				if(i == 0){
					return o2.getName().compareTo(o1.getName());
				}
				return i;
			}
		});
		ts.add(new Person("zs", 20));
		ts.add(new Person("lisi", 19));
		ts.add(new Person("wangwu", 18));
		Iterator<Person> it = ts.iterator();
		while(it.hasNext()){
			Person p = it.next();
			System.out.println(p.getName());
		}
	}
	
	@Test
	public void test4(){
		Map<String, Person> map = new HashMap<String, Person>();
		
		map.put("aa", new Person("zs", 20));
		map.put("bb", new Person("lisi", 19));
		map.put("cc", new Person("wangwu", 18));
		//1.遍历key
//		Set<String> keySet = map.keySet();
//		Iterator<String> it = keySet.iterator();
//		while(it.hasNext()){
//			String key = it.next();
//			Person person = map.get(key);
//			System.out.println(person.getName());
//		}
		
		//2.key和value当成一个entry实体
		Set<Entry<String, Person>> entrySet = map.entrySet();
		Iterator<Entry<String, Person>> it = entrySet.iterator();
		while(it.hasNext()){
			Entry<String, Person> entry = it.next();
			String key = entry.getKey();
			Person p = entry.getValue();
			System.out.println("键:" + key+ "--值:" + p.getName());
		}
	}
}

package com.jp;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class Demo3<T> {
	
	@Test
	public void test(){
		List<Person> personList = new ArrayList<Person>();
		
		List<String> strList = new ArrayList<String>();
		strList.add("aa");
		strList.add("bb");
		strList.add("cc");
		
		//personList.addAll(c) 
		
		//上限
		//Collection<? extends Person> 只能存储Person或者Person的子类
		
		//下限
		//Collection<? super Person> 只能存储Person或者Person的父类
		
		//Collection<?>  ?通配符
	}
}

package com.jp;

/*public class MyTool {
	private Object obj;

	public Object getObj() {
		return obj;
	}

	public void setObj(Object obj) {
		this.obj = obj;
	}
	
}*/

/*
 * 1.泛型可以用在类中
 * 
 * 2.泛型还可以用在方法上
 * 
 * 3.泛型还可以用在返回值上
 * 
 * 4.当方法是静态的，不能访问类上定义的泛型。如果静态方法要使用这个泛型，只能将
 * 泛型定义在方法上
 */


public class MyTool<W,U> {
	private W obj;

	public W getObj() {
		return obj;
	}

	public void setObj(W obj) {
		this.obj = obj;
	}
	
	public <Q> void show(Q q){
		
	}
	
	
	public static <U, Y> void print(U u , Y y){
		
	}
	
	public static void main(String[] args) {
//		MyTool<String> mt = new MyTool<String>();
//		mt.setObj("a");
		
	}
}

package com.jp;

public class Person implements Comparable<Person>{
	private String name;
	private Integer age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Person() {
		super();
	}
	public Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int compareTo(Person o) {
		int i = this.age.compareTo(o.getAge());
		if(i == 0){
			return this.name.compareTo(o.getName());
		}
		return i;
	}
	
	
}