java之16天 Map集合 (一)

Map 集合的使用

/**
 * Map集合: 该集合存储键值对,一对一对往里存,而且要保证键的唯一性
 *   1.添加
 *   	 	  put(K key,V value)
 *       void putAll(Map<? extends K,? extends V> m) 
 *   2.删除
 *        clear()
 *        remove()
 *   3.判断
 *   	 containsKey(Object Key)
 *       containsValue(Object value) 
 *       isEmpty()
 *       
 *   4.获取
 *       get(Object key) 
 *       size()
 *       values()
 *       Set<Map.Entry<K,V>> entrySet() 
 *       Set<K> keySet()
 *       
 *  Map
 *   |--HashTable: 底层是哈希表数据结构,不可以存入null键 和 null值,该集合是线程同步JDK 1.0. 无序
 *   |--HashMap:底层是哈希表数据结构,并允许使用null键null值,该集合不同步.JDK 1.2 效率高,无序
 *   |--TreeMap:底层是二叉树数据结构,线程不同步,可以用于给Map集合中的键排序.
 *   
 *  和 Set 很像 
 *     其实,Set底层就是使用Map集合.
 *
 */

public class MapDemo {
	
	public static void main(String[] args) {
		
		Map<String,String> map=new HashMap<String,String>();
		
		//添加元素,如果出现添加元素时,相同的键,那么后添加的值会覆盖原来键的对应值,并会返回被覆盖的值.
		map.put("01", "zhangsan1");
		map.put("02", "zhangsan2");
		System.out.println("put:"+map.put("03", "zhangsan3"));  //put 会返回 这个键对应的原来的值
		System.out.println("put:"+map.put("03", "zhangsan4"));
		
		System.out.println("containsKey:"+map.containsKey("022"));
		System.out.println("remove:"+map.remove("002"));//不存在的可以 就返回 null
		System.out.println("remove:"+map.remove("02")); //存在的 删除 并返回 要删除的对象
		System.out.println(map);
		System.out.println("get:"+map.get("03"));  //可以通过get方法的返回值来判断键是否存在
		
		map.put(null, "hah");  //HashMap可以使用 null键 null值 所以下面的能够取到值 HashTable就不行
		System.out.println("nullKey:"+map.get(null));
		
		
		map.put("04",null);   
		System.out.println("nullValue:"+map.get("04"));
		
		
		//获取Map集合中所有的值
		Collection<String> values=map.values();
		System.out.println(values);
		
		//获取Map集合的Key的所有值
		Set<String> keys=map.keySet();
		System.out.println(keys);
		
	}

}

Map 集合的两种取出方式

/**
 *Map 集合的两种取出方式
 * 1.Set<key> keySet: 将Map中的所有键存入的到Set集合中,因为Set具有迭代,所以可以用迭代方式取出所有的键 
 *         然后根据get方式,获取每个键对应的值
 *         
 *        Map集合的取出原理: 将Map集合   转成 Set集合  再通过迭代器 
 *        
 * 2.Set<Map.Entry<K,V>> entrySet: 将Map集合中的映射关系,存入Set集合中,
 *        而这个关系的数据类型就是Map.entry
 *        
 * Map.Entry<K,V>:其实Entry也是一个接口,他是Map接口中的一个内部接口
 * 
 * interface Map<K,V>{
 * 		public static interface Entry<K,V>{
 * 				public abstract K getKey();
 * 				public abstract V getValue();
 * 		}
 * 
 * }
 * 
 */
/*interface Map<K,V>{
	public static interface Entry<K,V>{
		public abstract K getKey();
		public abstract V getValue();
	}
}*/


public class MapDemo2 {

	public static void main(String[] args) {

		Map<String,String> map=new HashMap<String,String>();
		map.put("01", "zhangsan1");
		map.put("02", "zhangsan2");
		System.out.println("put:"+map.put("03", "zhangsan3"));  //put 会返回 这个键被覆盖的值
		System.out.println("put:"+map.put("03", "zhangsan4"));
		
		
		//1.使用 keySet
		
		//先获取Map集合的所有键的Set集合,KeySet();
		Set<String> keySet=map.keySet();
		//有了Set集合就可以获取其迭代器 
		Iterator<String> it=keySet.iterator();
		while(it.hasNext()){
			String key=it.next();
			String value=map.get(key);
			System.out.println("Key:"+key+",value:"+value);
		}
		System.out.println("==========================");
		
		//2.entrySet 将map集合中的隐射关系取出,存入到Set集合这个
		Set<Map.Entry<String, String>>  entrySet=map.entrySet();
		Iterator<Map.Entry<String, String>> it1=entrySet.iterator();
		while(it1.hasNext()){
			Map.Entry<String, String> me=it1.next();
			System.out.println("Key:"+me.getKey()+",value:"+me.getValue());
		}
		
	}

}

Map练习

/** Map练习
 *  每一个学生都有对应的归属地
 *  学生Student,地址 String
 *  学生属性 姓名 年龄
 *  注意:姓名和年龄相同视为同一个学习
 *  保证学生的唯一性.
 *  
 *  1.描述学习
 *  2.定义Map容器,将学生作为键,地址作为值,存入
 *  3.获取Map集合中的元素.
 *
 */
class Student implements Comparable<Student>{
	private String name;
	private int age;
	Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	@Override
	public String toString() {
		return name+":"+age;
	}
	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		return name.hashCode()+age*2;
	}
	@Override
	public boolean equals(Object obj) {
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");
		Student s=(Student)obj;
		return this.name.equals(s.name) && this.age==s.age;
	}
	@Override
	public int compareTo(Student o) {
		int num=new Integer(this.age).compareTo(new Integer(o.age));
		if(num==0)
			return this.name.compareTo(o.name);
		return num;
	}
	
}
class StuNameComparator implements Comparator<Student>{

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

public class MapDemo3 {
	public static void main(String[] args) {
		method();
		System.out.println("====================");
		method1();
		
	}
	
	//需求变了 需要保存进去的学生信息按 年龄排序
	public static void method1(){
		TreeMap<Student,String> tm=new TreeMap<Student,String>(new StuNameComparator());
		
		tm.put(new Student("lisi01",21), "北京");
		tm.put(new Student("lisi01",21), "天津");
		tm.put(new Student("alisi02",22), "上海");
		tm.put(new Student("elisi03",23), "武汉");
		tm.put(new Student("clisi04",24), "南京");
		
		Set<Map.Entry<Student, String>> entrySet=tm.entrySet();
		Iterator<Map.Entry<Student, String>> it1=entrySet.iterator();
		while(it1.hasNext()){
			Map.Entry<Student, String> me=it1.next();
			System.out.println(me.getKey()+"......"+me.getValue());
		}
		
	}
	
	public static void method(){

		HashMap<Student,String> hm=new HashMap<Student,String>();
		
		hm.put(new Student("lisi01",21), "北京");
		hm.put(new Student("lisi01",21), "天津");
		hm.put(new Student("lisi02",22), "上海");
		hm.put(new Student("lisi03",23), "武汉");
		hm.put(new Student("lisi04",24), "南京");
		
		//第一种取出方式 keySet
		Set<Student> keySet=hm.keySet();
		
		Iterator<Student> it=keySet.iterator();
		while(it.hasNext()){
			Student stu=it.next();
			String addr=hm.get(stu);
			System.out.println(stu+"......"+addr);
		}
		
		System.out.println("========================");
		//第二种取出方式 
		Set<Map.Entry<Student, String>> entrySet=hm.entrySet();
		Iterator<Map.Entry<Student, String>> it1=entrySet.iterator();
		while(it1.hasNext()){
			Map.Entry<Student, String> me=it1.next();
			System.out.println(me.getKey()+"......"+me.getValue());
		}
	}
	
	

}