【JavaSE学习笔记】集合03_Map,集合的嵌套

集合03

A.Map

1）需求：

在存储学生对象，每一个学生一个学号和姓名，通过学号去找学生

按照之前的集合操作,将学号和姓名作为当前类的成员封装起来,

然后遍历集合,将学号和学生姓名输出

没有必要这样去实现,因为如果很直接能拿到学生姓名,再遍历没意义

Java就提供了另一个集合Map集合<K,V>，是以一种键值对而存在

K--->键            V--->值

学号1----->姓名1

学号2----->姓名2

学号3----->姓名3

学号2----->姓名4（错误）

学号4----->姓名4

2）对于Map集合，针对的是键有效，跟值没有关系，键是唯一的，值是可以重复的

面试题：

Map集合和Collection区别？

Map：是一种键值对的一种映射关系，键是唯一的，值可以重复

双列集合------夫妻对

Collection：框架顶层的根接口，有两个子接口：List和Set

单列集合------光棍

3）添加功能

V put(K key, V value):添加元素(键和值的具体元素)

import java.util.HashMap;
import java.util.Map;

public class Demo01 {
	public static void main(String[] args) {
		// 创建Map集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 给集合中添加元素
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("段誉", "王语嫣");

		System.out.println(map);
		// {杨康=穆念慈, 郭靖=黄蓉, 段誉=王语嫣, 杨过=小龙女}
	}
}

其他用法：

如果键是第一次存储的时候，返回null

如果键已存在，再次存储的时候，将第一次的值返回，并且后面的值覆盖前面的

import java.util.HashMap;
import java.util.Map;

public class Demo01 {
	public static void main(String[] args) {
		// 创建Map集合对象
		Map<String, String> map = new HashMap<String, String>();

		System.out.println(map.put("文章", "马伊俐"));// 键第一次出现 返回null
		System.out.println(map);// {文章=马伊俐}

		System.out.println(map.put("文章", "姚笛"));// 键第二次出现返回值：马伊俐
		System.out.println(map);// {文章=姚笛} 鸠占鹊巢
	}
}

4）删除功能

a.void clear()：移除所有映射关系

import java.util.HashMap;
import java.util.Map;

public class Demo01 {
	public static void main(String[] args) {
		// 创建Map集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 给集合中添加元素
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("段誉", "王语嫣");

		System.out.println("原始数据：" + map);
		// 原始数据：{杨康=穆念慈, 郭靖=黄蓉, 段誉=王语嫣, 杨过=小龙女}

		map.clear();
		System.out.println("删除后：" + map);// 删除后：{}
	}
}

b.V remove(Object key)：删除键，返回值

import java.util.HashMap;
import java.util.Map;

public class Demo01 {
	public static void main(String[] args) {
		// 创建Map集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 给集合中添加元素
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("段誉", "王语嫣");

		System.out.println("原始数据：" + map);
		// 原始数据：{杨康=穆念慈, 郭靖=黄蓉, 段誉=王语嫣, 杨过=小龙女}

		System.out.println(map.remove("杨过"));// 小龙女
		System.out.println("删除后：" + map);// 删除后：{杨康=穆念慈, 郭靖=黄蓉, 段誉=王语嫣}
	}
}

5）判断功能

a.boolean containKey(Object Key)：判断当前集合是否存在key键

b.boolean containValue(Object Value)：判断当前集合是否存在value值

import java.util.HashMap;
import java.util.Map;

public class Demo01 {
	public static void main(String[] args) {
		// 创建Map集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 给集合中添加元素
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("段誉", "王语嫣");

		System.out.println(map.containsKey("杨过"));// true
		System.out.println(map.containsValue("黄蓉"));// true
	}
}

6）获取功能

a.V get(Object key)：返回键所对应的映射值

b.Set<K> keySet()：获取所有键的集合

c.Collection<V> values()：获取所有值的集合

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

public class Demo01 {
	public static void main(String[] args) {
		// 创建Map集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 给集合中添加元素
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("段誉", "王语嫣");

		// 获取某个键对应的值
		String value = map.get("杨过");
		System.out.println(value);// 小龙女

		// 获取所有的键集合
		Set<String> keySet = map.keySet();
		System.out.println(keySet);// [杨康, 郭靖, 段誉, 杨过]

		// 获取所有的值集合
		Collection<String> values = map.values();
		System.out.println(values);// [穆念慈, 黄蓉, 王语嫣, 小龙女]
	}
}

7）Map集合的遍历一

思路：Map-------夫妻对

a.获取所有的丈夫(K)的集合

b.让丈夫(K)找自己妻子(V)

c.将所有的丈夫(K)和妻子(V)的值输出

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

public class Demo01 {
	public static void main(String[] args) {
		// 创建Map集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 给集合中添加元素
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("段誉", "王语嫣");

		// 获取所有的键的集合
		Set<String> keySet = map.keySet();

		// 遍历所有的键的集合
		for (String key : keySet) {
			String value = map.get(key);
			System.out.println(key + "==" + value);
		}
	}
}

8）Map集合的遍历二

思路：

a.获取键值对对象的集合

b.遍历键值对对象的集合

c.通过简直对对象找键和值

问题：如何获取键值对对象呢？

Set<Map.Entry<K,V>> entrySet()获取键值对对象（存在地址值）

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

public class Demo01 {
	public static void main(String[] args) {
		// 创建Map集合对象
		Map<String, String> map = new HashMap<String, String>();

		// 给集合中添加元素
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("段誉", "王语嫣");

		// 获取键值对对象的集合
		Set<Entry<String, String>> entrySet = map.entrySet();

		for (Entry<String, String> entry : entrySet) {
			String key = entry.getKey();// 获取键
			String value = entry.getValue();// 获取值
			System.out.println(key + "---" + value);
		}
	}
}

9）两种遍历方式比较

10）HashMap<K, V>

是哈希表组成，键允许null，值也允许null，与Hashtable(不允许有null键和null值,)类似

不能保证元素的顺序恒久不变，与上面的Map用法一样

举例：使用集合存储对象（Student为键）

HashMap<Student, String>（如果String为键，则学号唯一）

String：学号

Student：学生（如果成员变量一致，认为是同一个对象）

所以：上面的学生类中要重写HashCode()和equals()-----（String为键不需要重写）

import java.util.HashMap;
import java.util.Set;

public class Demo01 {
	public static void main(String[] args) {
		// 创建集合对象
		HashMap<Student, String> hm = new HashMap<Student, String>();

		// 创建学生对象
		Student s1 = new Student("刘备", 27);
		Student s2 = new Student("关羽", 25);
		Student s3 = new Student("曹操", 29);
		Student s4 = new Student("刘备", 27);
		Student s5 = new Student("张飞", 20);
		
		//添加键值对元素
		hm.put(s1, "1001");
		hm.put(s2, "1002");
		hm.put(s3, "1003");
		hm.put(s4, "1004");
		hm.put(s5, "1005");
		
		//遍历集合元素
		Set<Student> set = hm.keySet();
		for (Student key : set) {
			String value = hm.get(key);
			System.out.println(key + "---" + value);
		}
		
	}
}

11）LinkedHashMap

底层是由哈希表和链表组成

哈希表：保证键的唯一性

链表：保证键的有序性

import java.util.LinkedHashMap;
import java.util.Set;


public class Demo01 {
	public static void main(String[] args) {
		//创建LinkedHashMap对象
		LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>();
		
		//存储元素
		lhm.put("1", "张三");
		lhm.put("2", "李四");
		lhm.put("3", "王五");
		lhm.put("4", "赵六");
		lhm.put("5", "杨七");
		
		//遍历
		Set<String> set = lhm.keySet();
		for (String key: set) {
			String value = lhm.get(key);
			System.out.println(key + "--" + value);
		}
	}
}

12）TreeMap

基于红黑树结果

两种排序：自然排序，比较器排序（参考TreeSet）

在这只介绍比较器排序中的匿名内部类（一模一样）

import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

public class Demo01 {
	public static void main(String[] args) {
		// 创建TreeMap集合
		TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>() {

			@Override
			public int compare(Student s1, Student s2) {
				// 按照主要条件：按照年龄大小
				int num = s1.getAge() - s2.getAge();
				// 年龄一样，按照姓名的内容
				int num2 = (num == 0) ? s1.getName().compareTo(s2.getName()) : num;
				return num2;
			}
		});

		// 创建学生对象
		Student s1 = new Student("李白", 20);
		Student s2 = new Student("杜甫", 25);
		Student s3 = new Student("苏轼", 33);
		Student s4 = new Student("李清照", 33);
		Student s5 = new Student("关汉卿", 33);

		// 给集合中添加元素
		tm.put(s1, "唐朝");
		tm.put(s2, "唐朝");
		tm.put(s3, "宋朝");
		tm.put(s4, "宋朝");
		tm.put(s5, "元朝");
		
		//获取所有的键的集合
		Set<Student> set = tm.keySet();
		for (Student key : set) {
			String value = tm.get(key);
			System.out.println(key + "---" + value);
		}
	}
}

13）Hashtable和HashMap的区别

HashMap：允许有null键和null值,从线程的角度考虑:线程不安全,不同步,执行效率高

Hashtable：不允许有null键,从线程的角度考虑:线程安全,同步,效率低

14）面试题:

List集合,Set集合,是继承自Map集合吗?

Map集合和Collection是不一样的，List,Set是Collection的两个子接口，跟Map没有关系

Map集合两个子实现类：HashMap  TreeMap

B.集合的嵌套

1）ArrayList<HashMap<K,V>>

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/**
 * 	需求： 假设ArrayList集合的元素是HashMap。有3个
 *  每一个HashMap集合的键和值都是字符串。 
 *  元素我已经完成，请遍历。 结果：
 *  	周瑜---小乔 
 *  	诸葛亮---黄月英
 * 
 * 		郭靖---黄蓉 
 * 		杨过---小龙女
 * 
 * 		乔峰---阿朱 
 * 		段誉---王语嫣
 */
public class Demo01 {
	public static void main(String[] args) {
		// 创建大集合对象
		ArrayList<HashMap<String, String>> al = new ArrayList<HashMap<String, String>>();
		
		// 创建第1个HashMap对象
		HashMap<String, String> hm1 = new HashMap<String, String>();
		// 添加元素
		hm1.put("周瑜", "小乔");
		hm1.put("诸葛亮", "黄月英");
		// 把hm1集合添加到al中
		al.add(hm1);
		
		// 创建第2个HashMap对象
		HashMap<String, String> hm2 = new HashMap<String, String>();
		// 添加元素
		hm2.put("郭靖", "黄蓉");
		hm2.put("杨过", "小龙女");
		// 把hm2集合添加到al中
		al.add(hm2);
		
		// 创建第3个HashMap对象
		HashMap<String, String> hm3 = new HashMap<String, String>();
		// 添加元素
		hm3.put("乔峰", "阿朱");
		hm3.put("段誉", "虚竹");
		// 把hm1集合添加到al中
		al.add(hm3);
		
		// 遍历
		for (HashMap<String, String> hm : al) {
			// 获取所有键的集合
			Set<String> set = hm.keySet();
			// 遍历所有键的集合
			for (String key : set) {
				String value = hm.get(key);
				System.out.println(key + "---" + value);
			}
			System.out.println();
		}
	}
}

2）HashMap<K, ArrayList<T>>

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/**
 * HashMap集合嵌套ArrayList集合 
 * 需求： 假设HashMap集合的元素是ArrayList。有3个。 
 * 每一个ArrayList集合的值是字符串。 
 * 元素我已经完成，请遍历。 
 * 结果：
 *  三国演义
 * 		吕布 
 * 		周瑜 
 * 	神雕侠侣 
 * 		郭靖 
 * 		杨过
 * 	天龙八部
 * 		乔峰
 * 		段誉
 */
public class Demo02 {
	public static void main(String[] args) {
		// 创建大集合对象
		HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
		
		// 创建集合元素1
		ArrayList<String> al1 = new ArrayList<String>();
		al1.add("吕布");
		al1.add("周瑜");
		// 大集合中添加元素
		hm.put("三国演义", al1);

		// 创建集合元素2
		ArrayList<String> al2 = new ArrayList<String>();
		al2.add("郭靖");
		al2.add("杨过");
		// 大集合中添加元素
		hm.put("神雕侠侣", al2);
		
		// 创建集合元素3
		ArrayList<String> al3 = new ArrayList<String>();
		al3.add("乔峰");
		al3.add("段誉");
		// 大集合中添加元素
		hm.put("天龙八部", al3);
		
		// 遍历
		Set<String> set = hm.keySet();
		for (String key : set) {
			System.out.println(key);
			
			ArrayList<String> value = hm.get(key);
			for (String s : value) {
				System.out.println("\t" + s);
			}
		}
	}
}

3）HashMap<K, HashMap<K,V>>

import java.util.HashMap;
import java.util.Set;

/**
 * HashMap集合嵌套HashMap集合 
 * 需求： 假设HashMap集合的元素是Hash。有3个。 
 * 结果：
 *  三国演义
 * 		周瑜---小乔 
 * 		刘备---孙尚香
 * 	神雕侠侣 
 * 		郭靖 ---黄蓉
 * 		杨过---小龙女
 * 	天龙八部
 * 		乔峰---阿朱
 * 		段誉---王语嫣
 */
public class Demo03 {
	public static void main(String[] args) {
		// 创建集合对象
		HashMap<String, HashMap<String, String>> hm = new HashMap<String, HashMap<String, String>>();
		
		// 创建第1个对象
		HashMap<String, String> hm1 = new HashMap<String, String>();
		hm1.put("周瑜", "小乔");
		hm1.put("刘备", "孙尚香");
		hm.put("三国演义", hm1);

		// 创建第2个对象
		HashMap<String, String> hm2 = new HashMap<String, String>();
		hm2.put("郭靖", "黄蓉");
		hm2.put("杨过", "小龙女");
		hm.put("神雕侠侣", hm2);
		
		// 创建第1个对象
		HashMap<String, String> hm3 = new HashMap<String, String>();
		hm3.put("乔峰", "阿朱");
		hm3.put("段誉", "王语嫣");
		hm.put("天龙八部", hm3);
		
		// 遍历
		// 遍历hm的键
		Set<String> hmSet = hm.keySet();
		for (String hmKey : hmSet) {
			System.out.println(hmKey);
			
			// hm的值，内层的键
			HashMap<String, String> value = hm.get(hmKey);
			Set<String> valueSet = value.keySet();
			// 内层的值
			for (String valueKey : valueSet) {
				String valueValue = value.get(valueKey);
				System.out.println("\t" + valueKey + "---" + valueValue);
			}
			System.out.println();
		}
	}
}