Map
1.Map
1.1 Map简介
1.为什么使用Map集合
购物车提供的四个商品和购买的数量在后台需要容器存储。
每个商品对象都一一对应一个购买数量。
把商品对象看成是Map集合的键，购买数量看成Map集合的值。
例如: {商品1=2 , 商品2=3 ， 商品3 = 2 , 商品4= 3}
2.Map集合和Collection集合有什么区别
Collection单列集合
Map 双列集合
3.怎么使用map集合
a.创建=>map是接口需要用多态的方式创建
b.增删改查数据
c.遍历
2.Map集合概述
HashMap中数据存储的结构是数组+链表/红黑树
Interface Map<K,V> K：键的数据类型；V：值的数据类型
键不能重复，值可以重复
键和值是一一对应的，每一个键只能找到自己对应的值
(键+值) 这个整体 我们称之为“键值对”或者“键值对对象”,在Java中叫做“Entry对象”。
举例：学生的学号和姓名
itgaohe001 小智
itgaohe002 小美
itgaohe003 大胖
创建Map集合的对象
1.多态的方式
2.具体的实现类HashMap
3.Map集合的基本功能
| 方法名 | 说明 |
|---|---|
| V put(K key,V value) | 添加元素,返回原来key对应的value值 |
| V remove(Object key) | 根据键删除键值对元素 返回被删除的值 |
| void clear() | 移除所有的键值对元素 |
| boolean containsKey(Object key) | 判断集合是否包含指定的键 |
| boolean containsValue(Object value) | 判断集合是否包含指定的值 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中键值对的个数 |
4.遍历Map集合
1.keyset()
2.Map.entrySet()
3.Map.forEach()
5.Map集合的获取功能
1.keyset()
| 方法名 | 说明 |
|---|---|
| V get(Object key) | 根据键获取值 |
| Set keySet() | 获取所有键的集合 |
2.Map.entrySet()
| 方法名 | 说明 |
|---|---|
| Set<Map.Entry<K,V>>entrySet() | 获取所有键值对对象的集合 |
| K getKey() | 获得键 |
| V getValue() | 获得值 |
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
String key = entry.getKey();
System.out.println("key:" + key);
Integer value = entry.getValue();
System.out.println("value:" + value);
// key:学号 value:202001 key:年龄 value:18
// System.out.println(entry);// 学号=202001 年龄=18
}
// System.out.println(entries);//[学号=202001, 年龄=18]
3.Map.forEach()
| 方法名 | 说明 |
|---|---|
| Set<Map.Entry<K,V>>entrySet() | 获取所有键值对对象的集合 |
| K getKey() | 获得键 |
| V getValue() | 获得值 |
map.forEach(new BiConsumer<String, Integer>() {
@Override
public void accept(String s, Integer integer) {
System.out.println(s + ":" + integer);
}
});
map.forEach((s, integer) -> System.out.println(s + ":" + integer));
2.HashMap
2.1HashMap的特点
HashMap是Map里面的一个实现类。
没有额外需要学习的特有方法，直接使用Map里面的方法就可以了
HashMap跟HashSet一样底层是哈希表结构的
2.2 HashMap的添加规则
2.3 HashMap小结
HashMap底层是哈希表结构的
依赖hashCode方法和equals方法保证键的唯一
如果键要存储的是自定义对象，需要重写hashCode和equals方法
Map<String, Animal> map = new HashMap<>();
map.put("老虎", new Animal("泰哥", 18));
Map<String, Animal> map1 = new HashMap<>();
map1.put("老虎", new Animal("泰哥", 18));
// map.put("狮子",new Animal("辛巴",18));
System.out.println(map.equals(map1));
2.4 案例：HashMap集合存储自定义对象并遍历
**需求：**创建一个HashMap集合，键是学生对象(Student)，值是籍贯(String)。存储三个键值对元素，并遍历
思路：
定义学生类
创建HashMap集合对象
创建学生对象
把学生添加到集合
遍历集合
public static void main(String[] args) {
HashMap<Student,String> hashMap = new HashMap<>();
hashMap.put(new Student("张三",18),"山东");
hashMap.put(new Student("李四",19),"山西");
hashMap.put(new Student("王五",20),"河南");
hashMap.put(new Student("马六",21),"河北");
Set<Map.Entry<Student, String>> entries = hashMap.entrySet();
for (Map.Entry<Student, String> entry : entries) {
System.out.println(entry);
}
}
2.5 探索键相同的本质？
默认调用Object的equals(Object o) 方法和hashCode()方法 比较key的内存地址如果修改了equals(Object o) 和 hashCode() 比较，则比较值相同
HashMap<Student, Student> hashMap = new HashMap<>();
Student s = new Student("张三",18);
hashMap.put(s, s);
s = new Student("张三2",19);
hashMap.put(s, s);
s = new Student("张三3",20);
hashMap.put(s, s);
s = new Student("张三4",21);
hashMap.put(s, s);
s = new Student("张三4",21);
hashMap.put(s, s);//重复值！ 只存了一次
Set<Map.Entry<Student, Student>> entries = hashMap.entrySet();
for (Map.Entry<Student, Student> entry : entries) {
System.out.println(entry);
}
//Student{name='张三', age=18}=Student{name='张三', age=18}
//Student{name='张三2', age=19}=Student{name='张三2', age=19}
//Student{name='张三3', age=20}=Student{name='张三3', age=20}
//Student{name='张三4', age=21}=Student{name='张三4', age=21}
//每put一次存一次值
2.6 案例：HashMap集合统计投票人数
一:需求：
某个班级80名学生，现在需要组成秋游活动，班长提供了四个景点依次是(A、B、C、D),每个学生只能选
择一个景点，请统计出最终哪个景点想去的人数最多。
二、分析
●将80个学生选择的数据拿到程序中去。
●定义Map集合用于存储最终统计的结果。
●遍历80个学生选择的数据,看Map集合中是否存在,不存在存入“数据=1 ", 存在则其对应值+1。
三、具体逻辑
1、把80个学生选择的数据拿进来。
2、定义一个Map集合记录最终统计的结果: A=30 B=20 C=20 D=10 键是景点,值是选择的数量
3、遍历80个学生选择的数据
4、提取当前选择景点字符
5、判断Map集合中是否存在这个键
6、如果Map集合中是存在这个键让其值+1，不存在则说明此景点是第一次被选。
代码展示：
public class Trip {
public static void main(String[] args) {
//1、把80个学生选择的数据拿进来。
String[] selects = {"A", "B", "C", "D"};
StringBuilder sb = new StringBuilder();
Random r = new Random();
for (int i = 0; i < 80; i++) {
sb.append(selects[r.nextInt(selects.length)]);
}
System.out.println(sb);
//2、定义一个Map集合记录最终统计的结果: A=30 B=20 C=20 D=10 键是景点,值是选择的数量
Map<Character, Integer> infos = new HashMap<>();
//3、遍历80个学生选择的数据
for (int i = 0; i < sb.length(); i++) {
//4、提取当前选择景点字符
char ch = sb.charAt(i);
//5、判断Map集合中是否存在这个键
if (infos.containsKey(ch)) {
//6、如果Map集合中是存在这个键让其值+1，
infos.put(ch, infos.get(ch) + 1);
}else {
//不存在则说明此景点是第一次被选。
infos.put(ch,1);
}
}
System.out.println(infos);
}
}
2.6 补充 StringBuilder StringBuffer String 联系与区别
String / StringBuffer / StringBuilder 是三个比较常见的类，都可以用来存放字符串但是三者有很多不同
1.三者的底层都是使用char[]数组进行数据的存放的
2.StringBuffer是线程安全的，StringBuilder是线程不安全的（底层方法都被synchronized修饰）
3.String是不可变的，StringBuffer和StringBuilder则是可变的
private final char value[]; 底层数据被final修饰
4.三者的效率从高到低排列：StringBuilder > StringBuffer > String
1.首先String无疑效率是最低的，由于String的不可变性，所以每次修改String的值无疑是在内存中重新创建了新的数组来存放所以String效率最低
2.StringBuffer由于使用了synchronized锁机制来保证线程安全，所以效率比StringBuilder要低
5.StringBuffer和StringBuilder底层默认构建长度为16的数组
6.StringBuffer和StringBuilder当字符串长度大于底层存放字符的数组的长度时就会触发扩容机制（扩容为原来的2倍+2）
在这里主要用到了 append追加方法。
2.7 案例：HashMap集合-省和市
需求：定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。添加完毕后，遍历结果格式如下:江苏省=南京市，扬州市，苏州市，无锡市，常州市湖北省 =武汉市，孝感市，十堰市，宜昌市，鄂州市河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市。
代码展示：
public class Test {
public static ArrayList<String> list = null;
public static void main(String[] args) {
Map<String, List<String>> map = new HashMap();
list = new ArrayList<>();
list.add("南京市");
list.add("扬州市");
list.add("苏州市");
list.add("无锡市");
list.add("无锡市");
list.add("无锡市");
list.add("无锡市");
map.put("江苏省", list);
list = new ArrayList<>();
list.add("武汉市");
list.add("孝感市");
list.add("十堰市");
list.add("宜昌市");
list.add("鄂州市");
list.add("常州市");
map.put("湖北省",list);
list = new ArrayList<>();
list.add("石家庄市");
list.add("唐山市");
list.add("邢台市");
list.add("保定市");
list.add("张家口市");
map.put("河北省 ",list);
Set<Map.Entry<String, List<String>>> entries = map.entrySet();
for (Map.Entry<String, List<String>> entry : entries) {
System.out.println(entry);
}
}
}
3.TreeMap
3.1 TreeMap的特点
TreeMap是Map里面的一个实现类。
没有额外需要学习的特有方法，直接使用Map里面的方法就可以了
TreeMap跟TreeSet一样底层是红黑树结构的
TreeMap底层是树形(红黑树)结构
3.2 案例：TreeMap练习
需求：创建商品的TreeMap集合,要求键存放商品的价格,值存放商品的名称,得到的商品集合可以按照商品价格升序或者降序进行排列
代码展示：
ShangPin
public class ShangPin{
private String name;
private Integer price;
get/set/tostring/wucan/youcan...
}
TreeMapTest
public static void main(String[] args) {
TreeMap<Integer, String> treeMap = new TreeMap<Integer,String>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
sp = new ShangPin("洗衣液", 100);
treeMap.put(sp.getPrice(), sp.getName());
sp = new ShangPin("洗手液", 50);
treeMap.put(sp.getPrice(), sp.getName());
sp = new ShangPin("洗面奶", 49);
treeMap.put(sp.getPrice(), sp.getName());
sp = new ShangPin("洗涤液", 30);
treeMap.put(sp.getPrice(), sp.getName());
System.out.println(treeMap);
}
自然排序
shangpin
implements Comparable<ShangPin>
---
@Override
public int compareTo(ShangPin o) {
return o.getPrice()-this.getPrice();
}
test
TreeMap<ShangPin,Integer> map = new TreeMap();
ShangPin s1 = new ShangPin("张三",5);
ShangPin s2 = new ShangPin("李四",0);
ShangPin s3 = new ShangPin("王五",6);
ShangPin s4 = new ShangPin("马六",51);
map.put(s1,11);
map.put(s2,11);
map.put(s3,22);
map.put(s4,33);
// System.out.println(map);
Set<Map.Entry<ShangPin, Integer>> entries = map.entrySet();
for (Map.Entry<ShangPin, Integer> entry : entries) {
System.out.println(entry);
}
}
3.3 TreeMap原理
3.4 TreeMap小结
TreeMap底层是红黑树结构的
依赖自然排序或者比较器排序，对键进行排序
如果键存储的是自定义对象，需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
3.5 案例：TreeMap练习
需求：创建一个TreeMap集合，键是学生对象(Student)，值是籍贯(String)。
学生属性姓名和年龄，按照年龄进行排序并遍历。
思路：
定义学生类
创建TreeMap集合对象
创建学生对象
把学生添加到集合
遍历集合
Student
public class Student {
private String name;
private int age;
Test
public static void main(String[] args) {
TreeMap<Student,String> treeMap = new TreeMap<Student,String>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
});
treeMap.put(new Student("张飞",18),"山东");
treeMap.put(new Student("关羽",12),"山东");
treeMap.put(new Student("黄忠",13),"山东");
treeMap.put(new Student("赵云",50),"山东");
treeMap.put(new Student("马超",26),"山东");
Set<Map.Entry<Student, String>> entries = treeMap.entrySet();
for (Map.Entry<Student, String> entry : entries) {
System.out.println(entry);
}
}
3.6 探索TreeMap 键排序的本质？
默认按照自然排序可以通过重写排序方法。一般默认不需要！
默认自然排序 升序排序。
3.7 案例：TreeMap练习
需求：字符串“aababcabcdabcde”
请统计字符串中每一个字符出现的次数，并按照以下格式输出
输出结果：
a（5）b（4）c（3）d（2）e（1）
public static void main(String[] args) {
TreeMap<Character, Integer> treeMap = new TreeMap();
String s = "aababcabcdabcde";
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
if (treeMap.containsKey(ch)) {
treeMap.put(ch,treeMap.get(ch)+1);
}else {
treeMap.put(ch,1);
}
}
Set<Map.Entry<Character, Integer>> entries = treeMap.entrySet();
for (Map.Entry<Character, Integer> entry : entries) {
System.out.println(entry.getKey()+"-----"+entry.getValue());
}
}
4.可变参数
4.1 案例：练习
需求：定义一个方法求两个数的和。
需求：定义一个方法求三个数的和。
需求：定义一个方法求N个数的和。
public class Test5 {
public static void main(String[] args) {
System.out.println(getSum(1, 2, 3, 5, 3));
}
public static int getSum(int... a) {
int sum = 0;
for (int i : a) {
sum += i;
}
return sum;
}
}
4.2 可变参数
可变参数：就是形参的个数是可以变化的
格式：修饰符 返回值类型 方法名(数据类型… 变量名) { }
范例：public static int sum(int… a) { }
可变参数注意事项
1.这里的变量其实是一个数组
2.一个方法里面不能包含多个可变参数
3.如果一个方法有多个参数，且包含可变参数，可变参数要放在最后
5.创建不可变的集合
5.1 方法
| 方法名 | 说明 |
|---|---|
| static List of(E…elements) | 创建一个具有指定元素的List集合对象 |
| static Set of(E…elements) | 创建一个具有指定元素的Set集合对象 |
| static <K , V> Map<K，V> of(E…elements) | 创建一个具有指定元素的Map集合对象 |
5.2 创建
在List、Set、Map接口中，都存在of方法，可以创建一个不可变的集合。
这个集合不能添加，不能删除，不能修改。
但是可以结合集合的带参构造，实现集合的批量添加。
在Map接口中，还有一个ofEntries方法可以提高代码的阅读性。
首先会把键值对封装成一个Entry对象，再把这个Entry对象添加到集合当中。
public static void main(String[] args) {
List<Integer> list = List.of(1, 2, 3, 4, 5);
System.out.println(list);
Set<String> set = Set.of("123", "465");
System.out.println(set);
Map<String, Integer> map = Map.of("赵云", 18, "赵2云", 19, "赵3云", 20, "赵4云", 5);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
System.out.println(entry);
}
}
但是可以结合集合的带参构造，实现集合的批量添加。
在Map接口中，还有一个ofEntries方法可以提高代码的阅读性。
首先会把键值对封装成一个Entry对象，再把这个Entry对象添加到集合当中。
public static void main(String[] args) {
List<Integer> list = List.of(1, 2, 3, 4, 5);
System.out.println(list);
Set<String> set = Set.of("123", "465");
System.out.println(set);
Map<String, Integer> map = Map.of("赵云", 18, "赵2云", 19, "赵3云", 20, "赵4云", 5);
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
System.out.println(entry);
}
}
![【Linux】-Linux的实用操作:快捷键与软件安装操作、构建软连接、日期时区的设置[4]](https://img-blog.csdnimg.cn/direct/7654e33cac074abc994fff5b95c8fd8d.png)