day10-Map集合

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);
        }
    }