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

65 阅读 0 评论 43 点赞

我是靠谱客的博主开朗发带，最近开发中收集的这篇文章主要介绍【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();
}
}
}