Map集合概述和特点
A: 需求: 根据学号获取学生姓名
B:Map接口概述
查看API可以知道：
将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值
C:Map接口和Collection接口的不同
Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效
案例:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.TreeMap;
public class MyTest {
public static void main(String[] args) {
//我们有学生 有可能会有重名学生
// key value 像这种键值映射关系的数据，在生活中经常键
// s001--------张三
// s002---------李四
// s003---------王五
ArrayList<String> list = new ArrayList<>();
list.add("s001--------张三");
list.add("s002---------李四");
list.add("s003---------王五");
//取出 s003 王五
String s = list.get(2);
String[] split = s.split("\\-+");
System.out.println(split[0]);
System.out.println(split[1]);
//Java 为了我们更加方便的去操作，这种键值映射关系的数据，给我们提供了另外一种集合叫做Map集合
//Map<K,V>将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
// HashMap, Hashtable, LinkedHashMap TreeMap Properties,
}
}
Map集合的功能概述
A:Map集合的功能概述
a:添加功能
V put(K key,V value):添加元素。这个其实还有另一个功能?替换
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
b:删除功能
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回
c:判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
d:获取功能
Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set keySet():获取集合中所有键的集合
Collection values():获取集合中所有值的集合
e:长度功能
int size()：返回集合中的键值对的对数
案例一：
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
public class MyTest2 {
public static void main(String[] args) {
//Collection 单列
//Map 双列集合
//HashSet 用的是HashMap来存的
//基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（
//双列集合，所有的数据结构,只跟键有关，跟值没关系
HashMap<String, String> map = new HashMap<>();
String v = map.put("文章", "马伊琍");
System.out.println(v);
//当发生键相同的时候，值就会覆盖，返回的是旧值
v = map.put("文章", "姚笛");
System.out.println(v);
map.put("贾乃亮", "李小璐");
map.put("王宝强", "蓉儿");
map.put("陈羽凡", "白百合");
map.put("武大", "潘金莲");
System.out.println(map);
}
}
结果：
null
马伊琍
{贾乃亮=李小璐, 文章=姚笛, 王宝强=蓉儿, 武大=潘金莲, 陈羽凡=白百合}
Map集合的基本功能测试
案例一：
import java.util.HashMap;
public class MyTest3 {
public static void main(String[] args) {
//先存 键是 String 类型 值是Student类型的
HashMap<String, Student> hashMap = new HashMap<>();
hashMap.put("s001",new Student("张三0",23));
hashMap.put("s001", new Student("张三0", 23));
hashMap.put("s001", new Student("张三0", 23333));
hashMap.put("s002", new Student("张三1", 23));
hashMap.put("s003", new Student("张三2", 23));
hashMap.put("s004", new Student("张三3", 23));
hashMap.put("s005", new Student("张三4", 23));
System.out.println(hashMap);
}
}
结果：
{s004=Student{name=‘张三3’, age=23}, s003=Student{name=‘张三2’, age=23}, s005=Student{name=‘张三4’, age=23}, s002=Student{name=‘张三1’, age=23}, s001=Student{name=‘张三0’, age=23333}}
案例二：
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
import java.util.HashMap;
public class MyTest4 {
public static void main(String[] args) {
// //双列集合，所有的数据结构,只跟键有关，跟值没关系
//存 键是 Student 值是String
HashMap<Student, String> hashMap = new HashMap<>();
hashMap.put(new Student("张三0", 23), "s001");
hashMap.put(new Student("张三0", 23), "s001");
hashMap.put(new Student("张三1", 23), "s002");
hashMap.put(new Student("张三2", 23), "s003");
hashMap.put(new Student("张三3", 23), "s004");
hashMap.put(new Student("张三4", 23), "s005");
System.out.println(hashMap);
}
}
结果：
{Student{name=‘张三0’, age=23}=s001, Student{name=‘张三3’, age=23}=s004, Student{name=‘张三2’, age=23}=s003, Student{name=‘张三4’, age=23}=s005, Student{name=‘张三0’, age=23}=s001, Student{name=‘张三1’, age=23}=s002}
案例三：
import java.util.HashMap;
public class MyTest2 {
public static void main(String[] args) {
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1,"aaa");
hashMap.put(1, "bbb");
hashMap.put(2, "ccc");
hashMap.put(3, "ddd");
hashMap.put(4, "eee");
hashMap.put(5, "fff");
// hashMap.clear(); //清空集合中所有的元素
hashMap.remove(4);//根据键移除这个键值对
boolean empty = hashMap.isEmpty();
System.out.println(empty);
System.out.println(hashMap);
}
}
结果：
false
{1=bbb, 2=ccc, 3=ddd, 5=fff}
案例四：
import java.util.HashMap;
import java.util.Set;
public class MyTest3 {
public static void main(String[] args) {
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1, "bbb");
hashMap.put(2, "ccc");
hashMap.put(3, "ddd");
hashMap.put(4, "eee");
hashMap.put(5, "fff");
//遍历map集合的方式1 键找值
Set<Integer> integers = hashMap.keySet();
// String s = hashMap.get(1); //键找值
for (Integer key : integers) {
System.out.println(key + "===" + hashMap.get(key));
}
}
}
结果：
2===ccc
3===ddd
4===eee
5===fff
Map集合遍历的两种方式比较
案例五：
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MyTest4 {
public static void main(String[] args) {
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1, "bbb");
hashMap.put(2, "ccc");
hashMap.put(3, "ddd");
hashMap.put(4, "eee");
hashMap.put(5, "fff");
//entrySet() 获取键值对 对象 放到Set集合里面去
Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();
//K getKey ()
//返回与此项对应的键。
//V getValue ()
//返回与此项对应的值。
for (Map.Entry<Integer, String> entry : entries) {
//System.out.println(entry);
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"==="+value);
}
}
}
结果：
1=bbb
2=ccc
3=ddd
4=eee
5===fff
案例五：
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;
public class MyTest {
public static void main(String[] args) {
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1, "aaa");
hashMap.put(1, "bbb");
hashMap.put(2, "ccc");
hashMap.put(3, "ddd");
hashMap.put(4, "eee");
hashMap.put(5, "fff");
// HashMap允许使用 null 值和 null 键。（
hashMap.put(null,null);
System.out.println(hashMap.get(null));
//获取所有键的集合
Set<Integer> integers = hashMap.keySet();
System.out.println(integers);
//获取所有值的集合
Collection<String> values = hashMap.values();
System.out.println(values);
//判断集合有没有1这个键
boolean b = hashMap.containsKey(1);
//判断集合中有么有bbb这个值
boolean flag = hashMap.containsValue("bbb");
//获取集合的长度
System.out.println(hashMap.size());
}
}
结果：
null
[null, 1, 2, 3, 4, 5]
[null, bbb, ccc, ddd, eee, fff]
6
LinkedHashMap的概述和使用
A:LinkedHashMap的概述: Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
B:LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一
元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
Map集合的数据结构只和键有关
C:案例演示: LinkedHashMap的特点
案例一：
Map集合遍历的两种方式比较
import com.sun.media.sound.SoftTuning;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
public class MyTest2 {
public static void main(String[] args) {
//键的数据结构是链表和哈希表，链表保证键有序，哈希表保证键唯一
LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("aaa", "AAA");
linkedHashMap.put("aaa", "AAA2");
linkedHashMap.put("ccc", "CCC");
linkedHashMap.put("ddd", "DDD");
linkedHashMap.put("eee", "EEE");
Set<String> strings = linkedHashMap.keySet();
for (String key : strings) {
System.out.println(key + "===" + linkedHashMap.get(key));
}
System.out.println("-------------------");
Set<Map.Entry<String, String>> entries = linkedHashMap.entrySet();
for (Map.Entry<String, String> en : entries) {
String key = en.getKey();
String value = en.getValue();
System.out.println(key + "===" + value);
}
}
}
结果：
aaa===AAA2
ccc===CCC
ddd===DDD
eee===EEE
-------------------
aaa===AAA2
ccc===CCC
ddd===DDD
eee===EEE
TreeMap集合
TreeMap 键不允许插入null
A: TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性
排序分为自然排序和比较器排序
线程是不安全的效率比较高
案例：
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(10,"aaaa");
treeMap.put(100, "aaaa");
treeMap.put(1, "aaaa");
treeMap.put(0, "aaaa");
treeMap.put(1044, "aaaa");
treeMap.put(1088, "aaaa");
Set<Integer> integers = treeMap.keySet();
for (Integer integer : integers) {
System.out.println(integer+"=="+treeMap.get(integer));
}
}
}
TreeMap集合两种遍历方式
案例一：
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo2 {
public static void main(String[] args) {
TreeMap<String, Integer> treeMap = new TreeMap<>();
treeMap.put("aaa", 111);
treeMap.put("ccc", 1110);
treeMap.put("d", 1119);
treeMap.put("fff", 1114);
treeMap.put("ggg", 1141);
treeMap.put("sss", 1161);
Set<Map.Entry<String, Integer>> entries = treeMap.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"==="+value);
}
}
}
案例二：
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo2 {
public static void main(String[] args) {
TreeMap<String, Integer> treeMap = new TreeMap<>();
treeMap.put("aaa", 111);
treeMap.put("ccc", 1110);
treeMap.put("d", 1119);
treeMap.put("fff", 1114);
treeMap.put("ggg", 1141);
treeMap.put("sss", 1161);
Set<Map.Entry<String, Integer>> entries = treeMap.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"==="+value);
}
}
}
TreeMap集合键是Student值是String的案例
案例一：
import java.util.Objects;
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public int compareTo(Student o) {
int num=this.age-o.age;
int num2=num==0?this.name.compareTo(o.name):num;
return num2;
}
}
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class MyTest {
public static void main(String[] args) {
TreeMap<Student, String> treeMap = new TreeMap<>();
treeMap.put(new Student("张三0", 23), "111");
treeMap.put(new Student("张三0", 23), "222");
treeMap.put(new Student("张三0", 23333), "222");
treeMap.put(new Student("张三1", 24), "444");
treeMap.put(new Student("张三2", 26), "555");
treeMap.put(new Student("张三3", 25), "666");
treeMap.put(new Student("张三4", 28), "777");
Set<Map.Entry<Student, String>> entries = treeMap.entrySet();
for (Map.Entry<Student, String> entry : entries) {
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"==="+value);
}
}
}
案例二：
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
import java.util.Comparator;
import java.util.TreeMap;
public class MyTest2 {
public static void main(String[] args) {
TreeMap<Student, String> treeMap = new TreeMap<>(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;
}
});
treeMap.put(new Student("张三0", 23), "111");
treeMap.put(new Student("张三0", 23), "222");
treeMap.put(new Student("张三0", 23333), "222");
treeMap.put(new Student("张三1", 24), "444");
treeMap.put(new Student("张三2", 26), "555");
treeMap.put(new Student("张三3", 25), "666");
treeMap.put(new Student("张三4", 28), "777");
}
}
统计字符串中每个字符出现的次数
A:案例演示: 需求：统计字符串中每个字符出现的次数
“aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
案例：
//A:
//案例演示:
//需求：统计字符串中每个字符出现的次数
//“aababcabcdabcde”, 获取字符串中每一个字母出现的次数要求结果:a(5) b(4) c(3) d(2) e(1)
// "aababcabcdabcde"
// "a(5) b(4) c(3) d(2) e(1)"
// 我们观察发现 a---5
// b---4
//c----3
// d---2
// e----1
//他是一种键值映射关系的数据
//那我就可以想到双列集合存起来
//然后遍历集合，拼串
//难点就是怎么统计字符出现的个数，以及把这个键值对应关系的数据存到集合中
import org.jcp.xml.dsig.internal.SignerOutputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class MyTest {
public static void main(String[] args) {
HashMap<Character, Integer> hashMap = new HashMap<>();
Scanner sc = new Scanner(System.in);
System.out.println("请输入一段字符串");
String str = sc.nextLine();
//遍历字符串
// char[] chars = str.toCharArray();
//"aababcabcdabcde";
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if (!hashMap.containsKey(ch)) {
hashMap.put(ch, 1);
} else {
//取出旧值
Integer integer = hashMap.get(ch);
integer++;
hashMap.put(ch, integer);//键相同值覆盖
}
}
//遍历集合，拼串
StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character, Integer>> entries = hashMap.entrySet();
for (Map.Entry<Character, Integer> entry : entries) {
sb.append(entry.getKey()).append("(").append(entry.getValue()).append(")");
}
String s = sb.toString();
System.out.println(s);
}
}
结果：
请输入一段字符串
asfddfdsdfsd
a(1)s(3)d(5)f(3)
集合嵌套之HashMap嵌套HashMap
A:案例演示
集合嵌套之HashMap嵌套HashMap
基础班
张三 20
李四 22
就业班
王五 21
赵六 23
案例：
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MyTest {
public static void main(String[] args) {
/* 基础班
张三 20
李四 22
就业班
王五 21
赵六 23
*/
//HashMap 嵌套 HashMap
HashMap<String, Integer> jc = new HashMap<>();
jc.put("张三", 20);
jc.put("李四", 22);
HashMap<String, Integer> jy = new HashMap<>();
jy.put("王五", 21);
jy.put("赵六", 23);
HashMap<String, HashMap<String, Integer>> maxMap = new HashMap<String, HashMap<String, Integer>>();
maxMap.put("基础班", jc);
maxMap.put("就业班", jy);
//遍历集合
Set<String> keySet = maxMap.keySet();
for (String s : keySet) {
System.out.println(s);
HashMap<String, Integer> minMap = maxMap.get(s);
Set<String> minKey = minMap.keySet();
for (String s1 : minKey) {
System.out.println("\t" + s1 + "\t" + minMap.get(s1));
}
System.out.println();
}
System.out.println("------------------------");
Set<Map.Entry<String, HashMap<String, Integer>>> entries = maxMap.entrySet();
for (Map.Entry<String, HashMap<String, Integer>> en : entries) {
String key = en.getKey();
System.out.println(key);
HashMap<String, Integer> minMap = en.getValue();
Set<Map.Entry<String, Integer>> entries1 = minMap.entrySet();
for (Map.Entry<String, Integer> stringIntegerEntry : entries1) {
String key1 = stringIntegerEntry.getKey();
Integer value = stringIntegerEntry.getValue();
System.out.println("\t"+key1+" "+value);
}
System.out.println();
}
}
}
结果：
就业班
王五 21
赵六 23
基础班
李四 22
张三 20
就业班
王五 21
赵六 23
基础班
李四 22
张三 20
HashMap 嵌套 ArrayList
案例：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Set;
public class MyTest2 {
public static void main(String[] args) {
/**
*
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过
*/
// HashMap 嵌套 ArrayList
ArrayList<String> sgList = new ArrayList<>();
sgList.add("吕布");
sgList.add("周瑜");
ArrayList<String> xaList = new ArrayList<>();
xaList.add("令狐冲");
xaList.add("林平之");
ArrayList<String> sdList = new ArrayList<>();
sdList.add("郭靖");
sdList.add("杨过");
sdList.add("尹志平");
LinkedHashMap<String, ArrayList<String>> maxMap = new LinkedHashMap<>();
maxMap.put("三国演义", sgList);
maxMap.put("笑傲江湖", xaList);
maxMap.put("神雕侠侣", sdList);
//遍历
/**
*
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过
*/
Set<String> keySet = maxMap.keySet();
for (String key : keySet) {
System.out.println(key);
ArrayList<String> list = maxMap.get(key);
for (String s : list) {
System.out.println("\t"+s);
}
System.out.println();
}
}
}
结果：
三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过
尹志平
ArrayList 嵌套 HashMap
案例：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MyTest3 {
public static void main(String[] args) {
//周瑜-- - 小乔
//吕布-- - 貂蝉
//
//郭靖-- - 黄蓉
//杨过-- - 小龙女
//
//令狐冲-- - 任盈盈
//林平之-- - 岳灵珊
//ArrayList 嵌套 HashMap
HashMap<String, String> sgMap = new HashMap<>();
sgMap.put("周瑜", "小乔");
sgMap.put("吕布", "貂蝉");
HashMap<String, String> sdMap = new HashMap<>();
sdMap.put("郭靖", "黄蓉");
sdMap.put("杨过", "小龙女");
HashMap<String, String> xaMap = new HashMap<>();
xaMap.put("令狐冲", "任盈盈");
xaMap.put("林平之", "岳灵珊");
ArrayList<HashMap<String, String>> maxList = new ArrayList<>();
maxList.add(sgMap);
maxList.add(sdMap);
maxList.add(xaMap);
for (HashMap<String, String> map : maxList) {
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "-----" + value);
}
System.out.println();
}
}
}
结果：
吕布-----貂蝉
周瑜-----小乔
杨过-----小龙女
郭靖-----黄蓉
令狐冲-----任盈盈
林平之-----岳灵珊
HashMap和Hashtable的区别
A:面试题
HashMap和Hashtable的区别: 查看API可以知道
HashMap: 线程不安全,效率高.允许null值和null键
Hashtable: 线程安全 , 效率低.不允许null值和null键
B:案例演示
HashMap和Hashtable的区别
291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
