折纸的不归路(16)

一.集合的后续–Map

如何确定排序

首先可以给一个正数或者给一个前-后,然后判定最后的顺序是否是我们需要的顺序,
如果不是,则进行调换
如果比较的是两个数字,前-后代表升序,后-前代表降序
如果比较的是两个字符串,我们可以调用字符串的自然排序的方法,compareTo方法
如果比较的是两个对象,且没有大小关系,可以通过返回正负数的方式来完成位置交换
奇数在前 偶数在后
第一个数是偶数,第二个数是奇数,所以返回一个正整数

Map保存的是键值对

Map有如下功能

增:put(k,v);
删:remove(k);
改:put(k,v);
查:get(k);
直接输出map对象得到的结果形式:
{key1=value1,key2=value2,…}

Map集合的遍历

map集合遍历的是key值还是value值?
value值,根据业务需求,有的时候也需要key-value的映射关系
1.map.values();获得所有的values(只知道values中的值,没有映射)
2.map.keySet();获得所有的keys,通过遍历keySet集合中的每个key值,得到对应的value值
3.map.entrySet();获得所有的key-value的集成对象entry,通过entry对象去获得key和value

Map功能的相关代码实现

package day14;
import java.util.*;

import com.briup.day06.Student;
public class MapTest {
	public static void main(String[] args) {
		Map map = new HashMap();
		//增
		map.put(1, "tom");
		map.put("2", new Student("tom",20,"男"));
		Student s1 = new Student("tim",21,"女");
		map.put(s1, 20.0);
		//删
		//根据key删除value,并且返回删除的value
//		System.out.println(map.remove("2"));
		//根据key和value删除,如果key和value不匹配,则删除失败
//		System.out.println(map.remove(s1, 20.0));
		//改
		map.put(1, "jerry");
		System.out.println(map);
		//查
		System.out.println(map.get(s1));
		//输出一下大小
		System.out.println(map.size());
		
		//遍历
		//1.
//		Collection c = map.values();
//		for(Object obj : c) {
//			System.out.println(obj);
//		}
		//2.
//		Set keys = map.keySet();
//		for(Object obj: keys) {
//			System.out.println("key="+obj);
//			System.out.println("value="+map.get(obj));
//			System.out.println("==========");
//		}
		//3.
		Set entrys = map.entrySet();
		for(Object obj : entrys) {
			if(obj instanceof Map.Entry) {
				Map.Entry me = (Map.Entry) obj;
				System.out.println(me.getKey());
				System.out.println(me.getValue());
				System.out.println("================");
			}
		}
		
	}
}

HashMap:无序的 验证key值的唯一性
HashTable:(古老的数据结构,加了线程安全,效率低)
SortedMap:
TreeMap:提供自然排序和客户化排序,对key值提供

二.泛型

在编译阶段进行类型检查
集合中使用泛型的语法
List<泛型>:当前List只能放该类型
Set<泛型>:
Map<泛型1,泛型2>:
例子:使用map保存一个复杂的数据结构
key值为学生或者人类
value为该学生或者人类的地址列表

Map<Persion,List<Address>>

利用泛型来完成Map

	
	package day14;
import java.util.*;

import day08.Addres;
import day08.Person;
/**
 * 使用泛型来完成map
 * @author Acer
 *
 */
public class MapTest2 {
	public static void main(String[] args) {
		Map<Integer,String> map1 = new HashMap<>();
		map1.put(1, "tom");
//		map1.put("2", "tom2");//泛型规定了数据类型
		map1.put(2, "tom2");
		System.out.println(map1.get(2));
		
		
		//key值和value值较为复杂的结构 day08
		Map<Person,List<Addres>> map2 = new TreeMap<Person,List<Addres>>(new Comparator<Person>() {

			@Override
			public int compare(Person o1, Person o2) {
				return o1.getName().compareTo(o2.getName());
			}
		});
		
		//准备map中的第一个元素
		Person p1 = new Person("tom",20,null);
		List<Addres> l1 = new LinkedList<>();
		Addres add1 = new Addres("中国","江苏","苏州");
		Addres add2 = new Addres("中国","山西","太原");
		l1.add(add1);
		l1.add(add2);
		map2.put(p1, l1);
		System.out.println("=========================");
		//准备第二个元素
		//先准备p2,再准备l2,再准备add3和add4
		//l2先添加add3和add4
		//map2添加p2和l2
		Person p2 = new Person("jerry",22,null);
		List<Addres> l2 = new LinkedList<>();
		Addres add3 = new Addres("中国","浙江","温州");
		Addres add4 = new Addres("中国","安徽","蚌埠");
		l2.add(add3);
		l2.add(add4);
		map2.put(p2, l2);
		
		//使用泛型来遍历,map2
		Set<Map.Entry<Person, List<Addres>>> entrys = map2.entrySet();
		for (Map.Entry<Person, List<Addres>> entry : entrys) {
			System.out.println(entry.getKey());
			System.out.println(entry.getValue());
		}
	}
}

泛型的高级应用

泛型类(拓展)

语法:class+类名<泛型>{}

泛型类的继承
如果子类要继承泛型父类,那么需要继承父类的所有泛型,
如果不需要继承泛型,则需要写明父类的泛型

泛型接口

语法 interface 接口名<泛型>{抽象方法}
实现类要实现该接口,如果不写明泛型,则实现的方法的参数和返回值都为Object,
所以要根据实际需求在实现接口是写明泛型

泛型方法

在泛型类中写泛型方法
	直接使用类中定义的泛型即可
在普通类中写泛型方法
	在方法的修饰符后面,返回值前面添加<泛型参数>,作用域为该方法

泛型通配符?

?通配无范围无边界的类型,使用?通配的集合不可以使用add方法添加元素,
只能加null元素,在编译阶段并不清楚需要什么类型

泛型的上下限

下限:泛型参数super Number//Number为泛型参数的下限
上限:泛型参数extends Number//Number为泛型参数的上限

手写一个map做手动的类型检查

(输入不能输入要求之外的类型,输出之后强转不报类型转换异常)–>MyMap

	package day14;
/**
 * 自己手动封装一个类型检查的Map类型
 * @author Acer
 *
 */
import java.util.*;
public class MyMap {
	private Map map = new HashMap();
	
	
	//只能够输入int类型的key和String类型的value
	public void put(int i, String s) {
		map.put(i, s);
	}
	//输出
	public String get(int i) {
		return (String)map.get(i);
	}
	
	//删除
	public String remove(int i) {
		return (String)map.remove(i);
	}
	
	public void show (List<Object> l) {
		System.out.println(l);
	}
	
	public static void main(String[] args) {
		MyMap mm = new MyMap();
		mm.put(1, "tom");
		mm.put(2, "jerry");
		System.out.println(mm.get(1));
		System.out.println(mm.get(1) instanceof String);
		List<String> list = new ArrayList<String>();
		List<Object> list1 = new ArrayList<Object>();
		System.out.println(list.getClass().getName());
		System.out.println(list1.getClass().getName());
//		mm.show(list);
	}
}

泛型的类型擦除

泛型的类型检查只是在编译阶段帮助控制输入的类型,
减少或者避免ClassCastException,编译器编译成功之后,
泛型会被擦除,也就是.class文件不存在泛型

反射原理:可以跳过编译阶段,直接修改Runtime的数据
可以直接跳过编译阶段,在泛型定义的list中add泛型之外的类型

泛型是jdk1.5之后提出的概念,jdk1.7之后提出的菱形语法(钻石语法)

泛型的相关测试

package day14;

import java.util.*;

import day08.Addres;

/**
 * 泛型测试
 * 
 * @author Acer
 *
 */
public class GenericTest {
	public static void main(String[] args) {
		Apple<String> a = new Apple<>("tom");
		System.out.println(a.getA() instanceof String);
		// 准备一个String类型的数组和String类型的集合
		Collection<String> coll = new ArrayList<String>();
		String[] array = new String[] { "tom", "jerry", "happy" };
		a.arrayToCollection(coll, array);
		System.out.println(coll.size());
		System.out.println(coll);// 输出结果
		// List<?> list = new ArrayList<>();//通配符?测试
		// list.add(null);
		// list.add(20.0);
		// list.add("String");
		
		Pear p = new Pear();
		Collection<Number> cn = new ArrayList<Number>() ;
		System.out.println(p.show(cn,2));
		
		
	}
}

//
class Apple<A> {// 形式参数类型取A是可以的,但是不符合规范
	private A a;

	// 提供构造器
	public Apple() {

	}

	public Apple(A a) {
		this.a = a;
	}

	// 提供get和set方法
	public A getA() {
		return a;
	}

	public void setA(A a) {
		this.a = a;
	}

	// 把一个A类型的数组变成集合
	public void arrayToCollection(Collection<A> coll, A[] array) {
		for (A temp : array) {
			coll.add(temp);
		}
	}

	// public Apple<A>(){
	//
	// }

}

interface AppleInterface<K, V> {
	void put(K k, V v);

	V get(K k);
}

class AppleB implements AppleInterface<String, Addres> {

	@Override
	public void put(String k, Addres v) {
		// TODO Auto-generated method stub

	}

	@Override
	public Addres get(String k) {
		// TODO Auto-generated method stub
		return null;
	}

}

interface PearInterface extends AppleInterface<Integer, String> {

}

interface BananaInterface extends AppleInterface<String, String> {

}

class Pear implements PearInterface {
//在普通类中声明一个泛型方法
	public <T> T show(Collection<? extends Number> t1,T t2) {
		System.out.println(t1);
		return t2;
	}
	@Override
	public void put(Integer k, String v) {
		// TODO Auto-generated method stub

	}

	@Override
	public String get(Integer k) {
		// TODO Auto-generated method stub
		return null;
	}

	
}

三.一点补充

Collections:集合中的工具类
	查找
	排序
	调换位置
	倒序输出
	随机打乱集合元素的顺序
Arrays:数组中的工具类

四.心得

今天早上辅导课及时的把TreeSet的相关内容做了相关的查漏补缺,把昨天的疑惑都解决了,今天上课的时候在treemap相关内容并没有再次绕进去,今天所学习的内容也都比较容易接受,在学Map的相关内容的时候明显比昨天第一次解除集合要好的多,一直懵逼的泛型今天也总算是正式学到了.明天继续加油!