数据类型笔记3

泛型类
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候
早期定义Object来完成扩展，现在定义泛型来完成扩展

package Generics;
/**
 * 泛型类 T其实指得是一个参数  当不确定Tool内部用何种类型时 可以这样定义
 * 好处就是提高了复用性  比如<T>中的T可以是worker可以是student可以是person
 * 在类的操作过程中不必为这个三个类各自定义Tool类  用着一个泛型类就可以 有点类似于
 * C++中的模板
 * @author bing
 *
 * @param <T>
 */
public class Tool<T> {
	private T  t;
	public void setObj(T t)
	{
		this.t=t;
	}
	public T getObjecrt()
	{
		return t;
	}
}

package Generics;

public class GenericDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Tool<Worker> worker_Tool = new Tool<Worker>();//定义工具类的时候将类型参数设定为Worker
		Tool<Manager> manager_Tool = new Tool<Manager>();//定义工具类的时候将类型参数设定为Worker
		worker_Tool.setObj(new Worker());
		manager_Tool.setObj(new Manager());
		Worker w1 = worker_Tool.getObjecrt();//不用类型强转，因为返回的就是worker类的对象
		Manager m1 = manager_Tool.getObjecrt();//不用类型强转，因为返回的就是worker类的对象
		System.out.println(w1.getClass());
		System.out.println(manager_Tool.getObjecrt().getClass());

	}

}

<pre class="java" name="code"></pre>

==================================================================================================

泛型方法 方法中使用泛型

package Generics;

public class GenericMethodDemo {
	public <T> void print(T t)
	{
		System.out.println("print"+t);
	}
	public <E> void show(E e)
	{
		System.out.println("show"+ e);
	}
}

package Generics;

public class GenericMethodTest {
	public static void main(String[] args) {
		GenericMethodDemo gmd = new GenericMethodDemo();
		gmd.print(new Worker());
		gmd.show(new Manager());
	}
}

输出：
printGenerics.Worker@1fc4bec
showGenerics.Manager@1bab50a


======================================================================
静态方法不可以访问类上定义的泛型
如果静态方法操作应用数据类型不确定，可以将泛型定义在方法上

public class GenericMethodTest {
	public static void main(String[] args) {
	    ssh("1234567890");
	}
	public static <T> void ssh(T t)
	{
		System.out.println(t);
	}
}

输出结果：1234567890

=====================================================================================
泛型的限定
<?>通配符，也可以理解为占位符
<? extends E>:可以接受E类型或者E类型的子类型 这个叫做上限
<? super E>:可以接受E类型或者E类型的父类型 这个叫做下限

练习，编写 Person类 ，Manager类和Worker类继承Person类 并且覆写Person类中的getName方法
编写一个泛型限定为上限Person的ArraryList 再编写一个输出方法 要求上限为Person输出集合中的对象的名字

package Generics;

public class Person {
	String name ;
	int age;
	
	public Person(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;
	}
	
}
package Generics;

public class Manager extends Person{

	public Manager(String name, int age) {
		super(name, age);
		
	}

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return (super.getName()+"Manager");
	}

	@Override
	public int getAge() {
		// TODO Auto-generated method stub
		return super.getAge();
	}
	
}
package Generics;

public class Worker extends Person{

	public Worker(String name, int age) {
		super(name, age);
	
	}

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return (super.getName()+"Worker");
	}

	@Override
	public int getAge() {
		// TODO Auto-generated method stub
		return super.getAge();
	}

}
package Generics;
import java.util.*;
public class GenericLimitDemo {
	public static void main(String[] args) {
		/**
		 * ArrayList(Collection<? extends E> c) //这里表示凡是继承自E的类都可以
          		构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的
		 */
		ArrayList<Person> arr = new ArrayList<Person>();//Person
		arr.add(new Worker("bing",25));//Worker
		arr.add(new Manager("bing", 31));//Manager
		print(arr);
	}
	
	public static void print(ArrayList<? extends Person> arr)
	{
		Iterator<? extends Person> it= arr.iterator();//泛型
		while(it.hasNext())
		{
			Person p = it.next();//多态
			System.out.println(p.getName()+"。。。。"+p.getAge());多态
		}
	}
}

输出
bingWorker。。。。25
bingManager。。。。31

=================================================================

Map集合：该集合存储键值对，一对一对的往里存。而且要保证键的唯一性
1.添加
put(k key,v value)
void putAll(Map<? extends K,? extends V> t) 从指定映射中将所有映射关系复制到此映射中（可选操作）。

2.删除
clear()
remove(Object key)
3.判断
boolean containsValue(Object value)
boolean containKey(Objcet key)
4.获取
get(Object key)
size()
Values()
entrySet()
KeySet()

Map下三个常用的实现类
HashMap：底层是哈希表数据结构 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。比hashtable效率高
HashTable: 底层是哈希表作为数据结构，不可以存入null键不可以存入null值
TreeMap：底层是二叉树结构。线程不同步。可以用于给map集合中的键进行排序
和Set很像，其实Set底层是使用了Map集合

演示代码如下：

package Map;
import java.util.*;
public class MapDemo {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		//添加 put
		map.put("01", "张东健");
		map.put("02","李政");
		map.put("03","金鱼住");
		System.out.println(map);
		map.put("03", "sdf");//注意这里，后添加的元素如果和上面的元素的键是一样的
		//则会覆盖前面的元素
		System.out.println(map);
		//判断  分别对键和值都能判断是否存在 containsKey containsValue
		System.out.println("map中是否还有01"+map.containsKey("01"));
		System.out.println("map中是否含有张东健"+map.containsValue("张东健"));
		//返回map集合中所有的值 Collection<V> values
		Collection<String> cllec = map.values();
		System.out.println("map"+map);
		System.out.println("Collection"+ cllec);
	}
}

=======================================================================
map集合取出元素的两种方式

package Map;

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

/**
 * map集合取出元素的两种方式
 * 1.keySet:将Map中所有的元素的键存入到Set集合。因为Set集合具有迭代器。
 * 这样可以用迭代的方式取出所有的键，再用get方法获取每一个键对应的值。
 * 		Map集合取出元素的原理：将Map集合通过keySet()方法转换成Set集合
 *      再有绑定到Set集合上的迭代器取出
 * 2.Set<Map.Entry<k,v>>entrySet: 将map集合中的映射关系存入到了set集合当中
 * 而这个关系的数据类型就是Map.Entry
 Map.Entry 其实就是Map中的内部接口（类似于内部类）
 * @author bing
 *
 */
public class KeySet_entrySetDemo {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		map.put("01", "张东健");
		map.put("02","李政");
		map.put("03","朴秀儿");
		map.put("04","金玉珠");
		map.put("05", "she");
		
		//将Map中的映射关系取出 用Set<Map.Entry<String,String>> mapEntrySet = map.entrySet() 取出map中的关系
		//再用迭代器取出
		Set <Map.Entry<String, String>> mapEntrySet = map.entrySet();
		Iterator<Map.Entry<String, String>> itm = mapEntrySet.iterator();
		while(itm.hasNext())
		{
			Map.Entry<String, String> me = itm.next();
			String key = me.getKey();
			String value = me.getValue();
			System.out.println("Key"+key+"。。。。"+ "value"+value);
		}
		
		/*
		//用一个Set集合接收map中通过keySet()方法返回的键的所有
		Set<String> keySet= map.keySet();
		Iterator<String> it = keySet.iterator();//keySet绑定迭代器
		String key;
		while(it.hasNext())
		{	key = it.next();
			System.out.println(key+map.get(key));
		}
		
		*/
	}
}

================================================================
用HashMap和TreeMap实现一个功能 提供一个学生类 分别想这两种集合中插入学生元素和地址元素
要求不可以出现同一个人 如果一个人的名字和年龄是统一的 则视为同一个人
hashMap中添加元素时 需要覆写学生类中的hashCode()方法和equals方法
而TreeMap中取出元素时则用传入自定义的迭代器比较器方法

package Map;

public class Student {
	String name;
	String age;
	@Override
	public int hashCode() {
		return name.hashCode() + age.hashCode()*13 ;
					
	}
	@Override
	public boolean equals(Object obj) {
		if(!(obj instanceof Student))
		{
			throw new RuntimeException("不是学生类对象");			
		}
		Student s = (Student)obj;
		if(this.name == s.getName()&& s.getAge() == this.age)
		{
			return true;
		}else
			return false;
		
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	public Student(String name, String age) {
	
		this.name = name;
		this.age = age;
	}
	
}

package Map;
import java.util.*;
public class StuItetator implements Comparator<Student>{

	public int compare(Student o1, Student o2) {
		int num = o1.getName().compareTo(o2.getName());
				if(num==0)
				{
					return o1.getAge().compareTo(o2.getAge()); 
				}
		return num;
	}

}
//Test 代码如下
package Map;
import java.util.*;
public class HashMapDemo {
	public static void main(String[] args) {
		HashMap<Student, String>  hm = new HashMap<Student, String>();
		hm.put(new Student("林书豪","24"), "纽约尼克斯");
		hm.put(new Student("kobe","34"), "洛杉矶湖人");
		hm.put(new Student("Yao","32"), "中国上海");
		hm.put(new Student("林书豪","24"), "纽约尼克斯");
		print(hm);
		System.out.println("----------------------");
		TreeMap<Student, String> tm = new TreeMap<Student, String>(new StuItetator());
		tm.put(new Student("lin","24"), "纽约尼克斯");
		tm.put(new Student("kobe","34"), "洛杉矶湖人");
		tm.put(new Student("Yao","32"), "中国上海");
		tm.put(new Student("Yao","35"), "中国上海");
		tm.put(new Student("林书豪","35"), "休斯顿火箭");
		print(tm);
		
		
	}
		public static void print (TreeMap<Student, String> tm)
		{
			Set<Map.Entry<Student, String>> set = tm.entrySet();
			Iterator<Map.Entry<Student, String>> it = set.iterator();
			while(it.hasNext())
			{
				Map.Entry<Student, String> me = it.next();
				System.out.println(me.getKey().getName()+me.getKey().getAge()+"....."+me.getValue());
			}
			
		}

	
	public static void print (HashMap<Student, String>  hm )
	{
		Set<Student> ke = hm.keySet();
		Iterator<Student> it = ke.iterator();
		while(it.hasNext())
		{
			Student stuKey = it.next();
			System.out.println(stuKey.getName()+stuKey.getAge()+ hm.get(stuKey));
		}
	}
}

输出结果：
kobe34洛杉矶湖人
Yao32中国上海
林书豪24纽约尼克斯
----------------------
Yao32.....中国上海
Yao35.....中国上海
kobe34.....洛杉矶湖人
lin24.....纽约尼克斯
林书豪35.....休斯顿火箭