黑马程序员——Java基础--集合（五）

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

第五讲 Map

一、概述
        存储的是俩个对象，映射键值对(a 1-->键a映射到值1) ， 键是唯一的，一对一的关系 ，Map<K,V> K 键的泛型 V值的泛型，将键值对存储到集合中put(K,V) ，put方法没有返回值，返回值数据类型是V类型，格式： V put(K,V) ，返回值的意思，存储了重复键，值就会被覆盖，put返回被覆盖之前的值。
        获取格式： V get(K)，根据键获取值，没有这个键，返回null
        Map中的接口方法：
        boolean containsKey(K)判断集合中有么有这个键；
        boolean containsValue(V)判断集合中有么有这个值；
        Collection values() 将Map中的所有值存储到Collection集合 。
二、迭代方式
1、 keySet方式
必须依赖于Set集合。Map接口中，keySet()；将Map集合 ，中所有的键存储到Set集合中，迭代Set集合，Map中的键，根据迭代Set的结果来 ，获取Map中的值。
实现步骤：
        1、调用Map中接口方法keySet,存储到Set集合。Set(K)
        2、迭代Set结合
        3、获取出来的就是Map中所有的键
        4、使用Map接口方法get通过键获取值
应用举例 ：

package cn.itheima.map;

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

/*
 * keySet方法
 * 步骤：
 * 1、调用Map中接口方法keySet，存储到集合Set
 * 2、迭代Set集合
 * 3、获取出来的是Map中所有的键
 * 4、用Map中get方法通过键获取值
 */
public class KeySetDemo {
	public static void main(String[] args) {
		//创建集合对象
		Map<String, String> map = new HashMap<String, String>();
		//添加元素到集合
		map.put("zhangsan", "beijing");
		map.put("lisi", "shanghai");
		map.put("wangwu", "tianjing");
		map.put("zhaoliu", "chongqing");
		//调用Map中接口方法keySet，存储到集合Set
		Set<String> set = map.keySet();
		//迭代Set集合
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			//获取出来的是Map中所有的键
			String next = it.next();
			//用Map中get方法通过键获取值
			System.out.println(next+"----"+map.get(next));
		}
	}
}

结果为：
zhaoliu----chongqing
wangwu----tianjing
lisi----shanghai
zhangsan----beijing
2、 ntrySet方式
实现步骤：
        1、Map集合方法entrySet,将键值对映射对象Entry存储到Set结合
        2、迭代Set集合
        3、Set集合存储的是Entry接口的实现类对象
        4、利用Entry接口实现类对象的方法getKey getValue
应用举例：

package cn.itheima.map;

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

/*
 * entrySet方式 
 * 1、用Map的entrySet方式存储到Set集合
 * 2、迭代Set集合
 * 3、Set集合存储的是Entry接口的实现类对象
 * 4、利用Entry接口实现类对象的方法getKey getValue
 */
public class EntrySetDemo {
	public static void main(String[] args) {
		//创建集合对象
		Map<String, String> map = new HashMap<String, String>();
		//添加元素到集合
		map.put("zhangsan", "beijing");
		map.put("lisi", "shanghai");
		map.put("wangwu", "tianjing");
		map.put("zhaoliu", "chongqing");
		//用Map的entrySet方式存储到Set集合
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		//迭代Set集合
		Iterator<Map.Entry<String, String>> it = entrySet.iterator();
		while(it.hasNext()){
			Map.Entry<String, String> next = it.next();
			String key = next.getKey();
			String value = next.getValue();
			System.out.println(key+"-----"+value);
		}
	}
}

结果为：
zhaoliu-----chongqing
wangwu-----tianjing
lisi-----shanghai
zhangsan-----beijing
三、HashMap
        底层数据结构，线程不安全呢，运行速度快，允许存储null值，null键 ，保证唯一性，重写HashCode和equals方法 ，增强for不能直接遍历Map，可以间接遍历。
举例：
学生类

package cn.itheima.hashmap;

public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(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;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}

测试类

package cn.itheima.hashmap;

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

/*
 * 案例 HashMap存储自定义对象,并两种方式迭代,自定义对象当作键
 * 
 */
public class HashMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		Map<Student, String> map = new HashMap<Student, String>();
		//添加元素到集合
		map.put(new Student("zhangsan", 20), "beijing");
		map.put(new Student("lisi", 19), "shanghai");
		map.put(new Student("wangwu", 22), "tianjing");
		//调方法
		keySet(map);
		System.out.println("-------------------------");
		entrySet(map);
	}
	public static void keySet(Map<Student, String> map){
		//调用Map的keySet方法存储到Set集合中
		Set<Student> ks = map.keySet();
		//迭代
		Iterator<Student> it = ks.iterator();
		while(it.hasNext()){
			Student next = it.next();
			System.out.println(next+"----"+map.get(next));
		}
	}
	public static void entrySet(Map<Student, String> map){
		//调用Map的entrySet方法存储到Set集合中
		Set<Map.Entry<Student, String>> es = map.entrySet();
		//迭代
		Iterator<Map.Entry<Student, String>> it = es.iterator();
		while(it.hasNext()){
			Map.Entry<Student, String> next = it.next();
			Student key = next.getKey();
			String value = next.getValue();
			System.out.println(key+"----"+value);
		}
	}
}

结果：
Student [name=wangwu, age=22]----tianjing
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing
-------------------------
Student [name=wangwu, age=22]----tianjing
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing

四、TreeMap
       底层结果红黑树，对存储（键）的对象进行排序，线程不安全，运行速度快。其排序方式有自然排序和比较器排序。
举例：TreeMap存储自定义对象,并两种方式迭代,自定义对象当作键。
学生类

package cn.itheima.treemap;

public class Student implements Comparable<Student>{
	private String name;
	private int age;
	public int compareTo(Student s) {
		//姓名为主要比较条件
		int num = this.name.compareTo(s.name);
		return num==0?this.age-s.age:num;
	}
	public int hashCode() {
		return this.name.hashCode()+this.age*31;
	}
	public boolean equals(Object obj) {
		if (obj==null) {
			return false;
		}if(this==obj){
			return true;
		}if(obj instanceof Student){
			Student s = (Student)obj;
			return this.name.equals(s.name)&&this.age==s.age;
		}
		return false;
	}

	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(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;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}


}

比较器

package cn.itheima.treemap;

import java.util.Comparator;

public class MyComparator implements Comparator<Student> {

	public int compare(Student s1, Student s2) {
		//比较年龄主要条件
		int age = s1.getAge()-s2.getAge();
		return age==0?s1.getName().compareTo(s2.getName()):age;
	}
}

测试类

package cn.itheima.treemap;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
import cn.itheima.treemap.Student;


/*
 *  案例 TreeMap存储自定义对象,并两种方式迭代,自定义对象当作键
 * 
 */
public class TreeMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		TreeMap<Student,String> map = new TreeMap<Student, String>(new MyComparator());
		//添加元素到集合
		map.put(new Student("zhangsan", 20), "beijing");
		map.put(new Student("lisi", 19), "shanghai");
		map.put(new Student("wangwu", 22), "tianjing");
		keySet(map);
	}
	public static void keySet(TreeMap<Student, String> map){
		Set<Student> ks = map.keySet();
		Iterator<Student> it = ks.iterator();
		while(it.hasNext()){
			Student next = it.next();
			System.out.println(next+"----"+map.get(next));
		}
	}
}

结果为：
Student [name=lisi, age=19]----shanghai
Student [name=zhangsan, age=20]----beijing
Student [name=wangwu, age=22]----tianjing

五、Map集合嵌套（俩种方式）

package cn.itheima.mapqiantao;

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

/*
 * Map嵌套
 * 	分析：
 * 	1、Java班分为基础班和就业班
 *  2、基础班有学生信息 学号"001" "张三" "002" "李四"
 *  3、就业班有学生信息 学号"001" "王五" "002" "赵六"
 *  4、Java班是一个集合，存储班级
 *  5、基础班和就业班分别是一个集合存储学生信息
 * 
 */
public class MapMapTest {
	public static void main(String[] args) {
		//创建Java班级集合
		Map<String, Map<String, String>> map = new HashMap<String, Map<String,String>>();
		//创建基础班集合
		Map<String, String> jichu = new HashMap<String, String>();
		Map<String, String> jiuye = new HashMap<String, String>();
		//添加元素到基础班和就业班集合中
		jichu.put("001", "张三");
		jichu.put("002", "李四");
		jiuye.put("001", "王五");
		jiuye.put("002", "赵六");
		//将班级集合添加到Java班级集合中
		map.put("基础班", jichu);
		map.put("就业班", jiuye);
		//调方法
		keySet(map);
		System.out.println("-------------------");
		entrySet(map);
	}
	//keySet方法
	public static void keySet(Map<String, Map<String, String>> map){
		//调用Map中keySet方法存储到Set集合中
		Set<String> ks = map.keySet();
		Iterator<String> it = ks.iterator();
		while(it.hasNext()){
			//next获取的Map 中的键,班级名字
			String next = it.next();
			//集合方法get获取值,值是一个集合,集合存储的是学生信息
			Map<String, String> map2 = map.get(next);
			//调用Map2中keySet方法存储到Set集合中
			Set<String> ks2 = map2.keySet();
			Iterator<String> it2 = ks2.iterator();
			while(it2.hasNext()){
				//next2获取的Map2 中的键,学生学号
				String next2 = it2.next();
				System.out.println(next+"----"+next2+"----"+map2.get(next2));
			}
		}
	}
	//entrySet方法
	public static void entrySet(Map<String, Map<String, String>> map){
		//调用Map中entrySet方法存储到Set集合中
		Set<Map.Entry<String, Map<String, String>>> entrySet = map.entrySet();
		Iterator<Map.Entry<String, Map<String, String>>> it = entrySet.iterator();
		while(it.hasNext()){
			//next获取的Map 中的键,班级名字
			Map.Entry<String, Map<String, String>> next = it.next();
			//键是班级名字
			String key = next.getKey();
			//值,是存储学生信息的班级集合
			Map<String, String> map2 = next.getValue();
			//调用Map2中entrySet方法存储到Set集合中
			Set<Map.Entry<String, String>> entrySet2 = map2.entrySet();
			Iterator<Map.Entry<String, String>> it2 = entrySet2.iterator();
			while(it2.hasNext()){
				//班级集合迭代器 next方法,获取到的是班级集合的键值对关系对象Entry
				Map.Entry<String, String> next2 = it2.next();
				//Entry方法getKey  getValue获取键值对,键是学号,值就是姓名
				String key2 = next2.getKey();
				String value = next2.getValue();
				System.out.println(key+"----"+key2+"----"+value);
			}
		}
	}
}

结果为：
就业班----001----王五
就业班----002----赵六
基础班----001----张三
基础班----002----李四
-------------------
就业班----001----王五
就业班----002----赵六
基础班----001----张三
基础班----002----李四

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------