day18

Map接口

• Map一次添加一对元素，Collection一次添加一个元素
• Map也称为双列集合
• map集合中存储的是键值对，要保证键的唯一性

常用方法

1. 添加

value put(key, value):返回前一个和key相关联的值，没有则返回Null

2. 删除

void clear();
value remove(key):根据指定的键移除键值对

3. 判断

boolean containsKey(key);
boolean containsValue(value);
boolean isEmpty();

4. 获取

value get(key):通过键获取值，如果没有该key，返回null
int size():获取键值对个数

keySet方法

Map<Integer,String> map = new HashMap<Integer, String>();
map.put(15,"scz");
map.put(20,"fxl");
map.put(17,"lzh");
method_2(map);
private static void method_2(Map<Integer, String> map) {

* 获取map中的所有元素
* 通过keySet方法获取map中所有键所在的集合set，再通过set的迭代器获取每一个键，然后遍历得到键对应的值			 
//	Set<Integer> keySet = map.keySet();
//	Iterator<Integer> it = keySet.iterator();这两行等效于下一行
Iterator<Integer> it = map.keySet().iterator();			
while(it.hasNext()) {
		Integer i = it.next();
		String value = map.get(i);
		System.out.println(i+":"+value);
	}
}

entrySet方法

private static void method_3(Map<Integer, String> map) {
/*
* entrySet,将键值对映射关系（结婚证）存储到Set集合中，映射关系的类型为Map.Entry
*/
Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
while(it.hasNext()) {
	Map.Entry<Integer,String> i = it.next();
	String value = i.getValue();
	Integer key = i.getKey();
	System.out.println(key+":"+value);
	}
}

常用子类

1. Hashtable:内部结构是哈希表，同步，不允许null作为键和值
2. HashMap：内部结构是哈希表，非同步，允许null作为键和值
3. TreeMap：内部结构是二叉树，非同步

泛型

• <>内为参数，为一个明确的具体引用数据类型，class,method,implements等，

ArrayList<String> a1 = new ArrayList<String>();//保证a1里面只能存String类型数据
a1.add("avsd");
//a1.add(3);报错，ClassCastException
Iterator<String> it = a1.iterator();
//String s = (String)it.next();确保了迭代器里面只有String类型，因此不再需要类型转换
String s = it.next();

泛型类

//泛型类，当类中操作的引用数据类型不确定时使用，以前都是直接用Object类表示，但是泛型更安全
public class Tool<Q> {
		private Q q;
		public Q getobj() {
			return q;
		}
		public void setobj(Q obj) {
			this.q = obj;
		}		
}

泛型方法

//非静态方法可以直接调用类的泛型
public  void run(Q str) {
	System.out.println("run"+str.toString());
}
//或定义一个新的泛型在方法上
public <w> void show(w str) {
	System.out.println("show"+str.toString());
}
//当方法为静态方法时，无法调用类的泛型，必须定义在方法上
public static <y> void print(y str) {
	System.out.println("print"+str.toString());
}
Tool<Person> t = new Tool<Person>();
t.show("hh");
t.show(new Integer(5));
Tool.print("xixi");

泛型限定

ArrayList<String> al = new ArrayList<String>();
al.add("abc");
al.add("scz");			
HashSet<Integer> hs = new HashSet<Integer>();
hs.add(4);
hs.add(17);			
printcollection(al);
printcollection(hs);
//?表示通配符，在类型未知时使用，可以对所有引用数据类型进行操作
public static void printcollection(Collection<?> s) {
	Iterator<?> it = s.iterator();
	while(it.hasNext()) {
		System.out.println(it.next());
	}
//特殊情况如下：现在我们只想对Person及其子类进行操作，则使用以下参数形式,称为泛型的上限
Worker extends Person;Student extends Person;		
public static void printcollection(Collection<? extends Person> s) {
	Iterator<? extends Person> it = s.iterator();
	while(it.hasNext()) {
		Person p = it.next();
		System.out.println(p.getAge()+p.getName());
	}
}
//同样也有对父类进行操作的表示形式，称为泛型的下限,应用不多
public static void printcollection(Collection<? super Student> s) {}

• 不能对使用通配符的集合添加任何元素
• 原因：当我们使用通配符时，并没有给出一个指定的引用数据类型，处于安全起见，不允许添加元素
• 如：List<?extends Person> list1 = new ArrayList();list1不能添加元素只能取