黑马程序员技术交流社区

标题: 11/16日笔记day04 Map集合 今日内容 [打印本页]

---

作者: 849618121    时间: 2018-11-20 17:21
标题: 11/16日笔记day04 Map集合 今日内容


Map双列集合
        特点
        常用方法
        2种遍历方式
        自定义对象作为 key(键) value(值)
        HashMap, LinkedHashMap, Hashtable
JDK9 快速创建集合
IDEA Debug调试功能
斗地主发牌(排序版)
Map体系
Map集合概述知识点
Map双列集合有什么特点
Map集合适合存储什么样的数据
总结:
java.util.Map<K, V>接口Map集合特点:
        1. 是双列集合, 一个元素包含两个值 (键key, 值value) 键值对
        2. key和value的类型可以相同, 也可以不同
        3. key不允许重复, value可以重复
        4. key和value是一一对应的, 一个键只能对应一个值Map集合适合存储"一对一关系"的数据
        夫妻
        String : Phone
        统计次数: 某个字符出现了多少次  "aaababababba"
                'a': 1
        'b': 3
补充:
public class Node<K, V> {
    K key;
    V value;
}
Map常用子类知识点
Map接口有哪些常用实现类
HashMap类有什么特点
总结:
java.util.Map<K, V>接口: 双列集合的根接口, 规定了共性的方法
        |
        |_ HashMap<K, V>类: 底层哈希表. key存取无序不可重复  
                |_ LinkedHashMap<K, V>类: 底层哈希表+链表. key存取有序不可重复
               
映射: 键和值的对应关系 mappingHashSet底层使用的就是HashMap
LinkedHashSet底层使用的就是LinkedHashMap
补充: Map中常用方法知识点
Map接口中定义的共性方法有哪些
如何添加键值对
总结:
java.util.Map接口: 双列集合的顶层
        // 成员方法
        V put(K key, V value): 添加/修改 键值对.
            如果键存在, 则用新值替换已有值, 返回被替换的值; 如果键不存在, 添加键值对, 返回null
        V remove(Object key): 根据键删除键值对, 返回被删除元素的值
                如果键不存在, 返回null
        V get(Object key): 根据键获取值.
            如果键不存在, 则返回null
        boolean containsKey(Object key): 判断是否包含指定的键
        
        Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
        Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的Entry对象的集合(Set集合)



补充:
entry 节点

public class Entry<K,V> {  // 键值对 对象
        K key;
        V value;
    }
5分钟练习: 测试Map常用方法
需求:
创建HashMap对象, 存储键值对都是String, 存储以下键值对
        黄晓明, 杨颖
        文章, 马伊琍
        邓超, 孙俪
删除文章马伊琍
获取邓超的老婆打印出来
判断键中是否有黄晓明
代码:
public class Test {
    public static void main(String[] args) {
        // 创建Map集合, 用多态也行, 不用多态也行
        // 注意泛型有2个, 左边是键的类型, 右边是值的类型
        Map<String, String> map = new HashMap<>();        // 添加夫妻对
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("邓超", "孙俪");
        System.out.println(map);  // {邓超=孙俪, 文章=马伊琍, 黄晓明=杨颖}
        // key 存取无序, 不可重复

        // 删除文章马伊琍
        String removedValue = map.remove("文章");
        System.out.println("删除文章返回的值:" + removedValue); // 删除文章返回的值:马伊琍
        System.out.println(map);  // {邓超=孙俪, 黄晓明=杨颖}        // 获取邓超的老婆打印出来
        String value = map.get("邓超");
        System.out.println("通过邓超获取的值:" + value);  // 通过邓超获取的值:孙俪
        System.out.println(map); // {邓超=孙俪, 黄晓明=杨颖}        // 判断键中是否有黄晓明
        boolean b = map.containsKey("黄晓明");
        System.out.println("是否包含黄晓明这个key:" + b); // 是否包含黄晓明这个key:true
    }
}
Map遍历方式一: keySet()方法实现通过键找值知识点
如何利用 keySet() 方法实现Map的遍历
总结:
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
        
keySet()遍历步骤:
        1. Map对象调用 keySet() 方法, 获取包含所有key的Set集合
        2. 遍历Set集合, 获取每个key
        3. 通过Map对象调用 get(Object key) 方法根据key获取到value
        
        Map<String, String> map = new HashMap<>();
        // keySet()遍历
        Set<String> keys = map.keySet();
        for (String key : keys) {
                // 通过每个键获取值
                String value = map.get(key);
                // 打印当前键值对
                System.out.println(key + "=" + value);
        }
补充: 5分钟练习: keySet()遍历Map
需求:
创建HashMap集合, 存储以下键值对
        "赵丽颖", 168
        "杨颖", 165
        "林志玲", 178
使用keySet()方式遍历Map, 打印键值对, 效果:
        林志玲=178
        赵丽颖=168
        杨颖=165
代码:
public class Test {
    public static void main(String[] args) {
        // 创建Map集合
        HashMap<String, Integer> map = new HashMap<>();        // 添加键值对
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志玲", 178);        // 通过keySet()先获取包含所有key的set集合
        Set<String> keySet = map.keySet();
        // 遍历set集合, 获取每个key
        for (String key : keySet) {
            // 通过key获取value
            Integer value = map.get(key);
            // 打印键值对
            System.out.println(key + "=" + value);
        }        System.out.println("-------------------");        // 简化的增强for循环
        for (String key : map.keySet()) {
            // 通过key获取value
            Integer value = map.get(key);
            // 打印键值对
            System.out.println(key + "=" + value);
        }        System.out.println("-------------------");        // 迭代器
        Iterator<String> iterator = keySet.iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }
    }
}
Entry键值对对象介绍知识点
Map中的存储的 键值对 和 Entry对象 有什么关系
总结:
java.util.Map.Entry接口:
        // 常用成员方法
        K getKey(): 获取Entry对象中的键
        V getValue(): 获取Entry对象中的值
        
Entry对象就是一个节点, 节点中存储了key和value
拿到一个Entry对象就可以从中获取key和value
        
        // HashMap中Entry实现类
        static class Node<K,V> implements Map.Entry<K,V> {
            final int hash;
            final K key;
            V value;
            Node<K,V> next;            public final K getKey() {
                return key;
            }

            public final V getValue() {
                return value;
            }
        }java.util.Map接口
        Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
补充: Map遍历方式2: 通过entrySet()获取Entry对象形式遍历知识点
如何利用Map的 entrySet() 方法进行遍历
总结:
java.util.Map接口
        Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)

entrySet()方法遍历Map步骤:
        1. Map对象调用 entrySet() 获取包含所有Entry对象的Set集合
        2. 遍历Set集合, 获取每个Entry对象
        3. 调用Entry对象的 getKey() 和 getValue() 方法获取键和值
        
        Map<String, String> map = new HashMap<>();
        // keySet()遍历
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            // 通过Entry对象获取每个键值对
            String value = entry.getKey();
            String value = entry.getValue();
            // 打印当前键值对
            System.out.println(key + "=" + value);
        }
补充: 5分钟练习: entrySet()遍历Map
需求:
创建HashMap集合, 存储以下键值对
        "赵丽颖", 168
        "杨颖", 165
        "林志玲", 178
使用entrySet()方式遍历Map, 打印键值对, 效果:
        赵丽颖=168
        杨颖=165
        林志玲=178
代码:
public class Test {    public static void main(String[] args) {
        // 创建Map集合
        HashMap<String, Integer> map = new HashMap<>();        // 添加键值对
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志玲", 178);        // 使用entrySet遍历
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        // 遍历包含所有entry对象的set集合, 取出每个entry对象
        for (Map.Entry<String, Integer> entry : entrySet) {
            // 通过entry对象分别获取key和value
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }        System.out.println("-----------------");        // 简化的增强for
        for (Map.Entry<String, Integer> entry : map.entrySet()) {  // map.entrySet().for 回车
            // 通过entry对象分别获取key和value
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }        System.out.println("-----------------");        // 迭代器
        Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> entry = iterator.next();
            // 通过entry对象分别获取key和value
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}
HashMap存储自定义数据类型作为键知识点
HashMap存储自定义JavaBean对象作为key, 如何保证key唯一不重复
总结:
HashMap存储自定义JavaBean对象作为key保证key唯一不重复, 需要让JavaBean重写 hashCode() 和 equals() 方法
补充: 5分钟练习: 使用自定义JavaBean作为key
需求:
定义Person类:
        私有成员变量: 姓名String name, 年龄int age
        生成无参/有参构造, set/get方法, toString, hashCode(), equals()
定义测试类:
        创建4个Person对象, 分别如下:
                "女王", 18
                "秦始皇", 18
                "普京", 30
                "女王", 18
        创建HashMap集合, 存入键为4个Person对象, 值为对应国家字符串: 英国, 秦国, 俄罗斯, 毛里求斯
        使用entrySet()方法遍历Map集合, 输出键值对
代码:
public class Test {
    public static void main(String[] args) {
        // 创建4个Person对象
        Person p1 = new Person("女王", 18);
        Person p2 = new Person("秦始皇", 18);
        Person p3 = new Person("普京", 30);
        Person p4 = new Person("女王", 18);

        // 创建HashMap集合
        HashMap<Person, String> map = new HashMap<>();        map.put(p1, "英国");
        map.put(p2, "秦国");
        map.put(p3, "俄罗斯");
        map.put(p4, "毛里求斯");        // 遍历
        Set<Map.Entry<Person, String>> entrySet = map.entrySet();
        for (Map.Entry<Person, String> entry : entrySet) {
            // 通过entry对象获取key和value
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "-->" + value);
        }
    }
}
LinkedHashMap类知识点
LinkedHashMap底层使用什么数据结构, 有什么特点
总结:
LinkedHashMap底层: 哈希表 + 链表
        key不允许重复, 但key存取有序
补充: Hashtable类知识点
Hashtable和HashMap有什么相同点和不同点
总结:
Hashtable和HashMap:
        相同点:
                1. 底层都是哈希表
        不同点:
                1. Hashtable不允许存储 null 值和 null 键; HashMap允许存储 null 值和 null 键
                2. Hashtable线程安全效率低; HashMap线程不安全效率高
               
Hashtable目前很少使用.
但其子类 Properties 集合, 可以与IO流结合使用, 应用较多
补充: Map集合练习
5分钟练习: 利用Map计算字符串中每个字符出现的次数
需求: 键盘录入一个字符串, 计算一个字符串中每个字符出现次数"aaabbbbccc"a:2
b:4
c:3分析:
    1.使用Scanner获取用户输入的字符串
    2.创建Map集合,key是字符串中的字符,value是字符的个数
    3.遍历字符串,获取每一个字符
    4.使用获取到的字符,去Map集合判断key是否存在 containsKey()
        key存在:
            通过字符(key),获取value(字符个数)
            value++
            put(key,value)把新的value存储到Map集合中
        key不存在:
                put(key,1)
    5.遍历Map集合,输出结果
代码:
public class Test {
    public static void main(String[] args) {
        // 键盘录入
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String s = scanner.next();        // 创建Map集合
//        Map<Character, Integer> map = new HashMap<>();
        Map<Character, Integer> map = new TreeMap<>(); // TreeMap        // 将字符串转换为char[]
        char[] arr = s.toCharArray();
        // 遍历字符数组中的字符
        for (char c : arr) {
            // 先判断该字符是否在map中存储过
            if (map.containsKey(c)) {
                // 包含该key, 则需要取出value的次数, 增加1, 再存回去
                Integer count = map.get(c);
                count++;
                map.put(c, count);
            } else {
                // 不包含该key, 则认为是第一次遇到, 次数为1次
                map.put(c, 1);
            }
        }        // 遍历map查看
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            Character ch = entry.getKey();
            Integer count = entry.getValue();
            System.out.println(ch + "=" + count);
        }
    }
}
JDK9对集合添加的优化知识点
JDK 9 中新增的快速添加多个元素的方法如何使用
有什么注意事项
总结:
使用集合添加大量元素时, 反复add(...)比较麻烦. JDK 9 为集合提供了一些静态方法, 可以方便的对集合进行初始化java.util.List接口:
        // 静态方法
        static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
        
java.util.Set接口:
        // 静态方法
        static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
        
java.util.Map接口:
        // 静态方法
        static Map<K, V> of(K k1, V v1, ...): 返回包含指定键值对的 不可变Map 集合
        
注意事项:
        1. of() 方法只适用于List接口, Set接口, Map接口, 不适用于接口的实现类
        2. of() 方法的返回值是一个不可变的集合, 集合不能再使用 add(), put() 方法添加元素, 会抛出异常
        3. Set接口和Map接口在调用 of() 方法的时候, 不能有重复的元素, 否则会抛出异常
补充:
将 不可变集合 的元素转移到常见集合实现类中:
        // List
    ArrayList<Integer> list = new ArrayList<>(List.of(1,2,3));        // Set
    HashSet<Integer> set = new HashSet<>(Set.of(1,2,3));        // Map
    HashMap<Integer, String> map = new HashMap<>(Map.of(1,"a",2,"b")); 5分钟练习: 使用of方法快速添加元素
需求:
使用List.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
使用Set.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
使用Map.of()方法, 添加"a":1, "b":2, "c":3, 获取集合对象, 使用entrySet()遍历打印输出
代码:
public class Test {
    public static void main(String[] args) {
        // 使用List.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
        List<Integer> list = List.of(1, 2, 3);  // 得到是不可变集合, 只能获取元素, 不能添加
        for (Integer i : list) {
            System.out.println(i);
        }        // 使用有参的ArrayList构造方法, 将不可变集合转换为可变集合
        ArrayList<Integer> arrayList = new ArrayList<>(list);
        arrayList.add(4);
        arrayList.add(5);
        System.out.println(arrayList);        System.out.println("-----------------");        // 使用Set.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
        Set<Integer> set = Set.of(1, 2, 3);
        for (Integer i : set) {
            System.out.println(i);
        }        System.out.println("-----------------");        Map<String, Integer> map = Map.of("a", 1, "b", 2, "c", 3);
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}
Debug调试模式介绍知识点
Debug调试有什么作用
如何Debug
如何添加断点
如何删除断点
如何在debug模式下运行
总结:
断点:
        breakpoint, 在debug模式下, 程序运行到断点会暂停住, 便于我们在程序运行过程中查看
Debug调试程序:
    可以让代码逐行执行,查看代码执行的过程,调试程序中出现的bug
使用方式:
    在行号的右边,鼠标左键单击,添加断点(每个方法的第一行,哪里有bug添加到哪里)
    右键,选择Debug执行程序
    程序就会停留在添加的第一个断点处
执行程序:
    f8:逐行执行程序
    f7:进入到方法中
    shift+f8:跳出方法
    f9:跳到下一个断点,如果没有下一个断点,那么就结束程序
    ctrl+f2:退出debug模式,停止程序
    Console:切换到控制台
补充: 斗地主发牌案例
有(大小)序斗地主: 需求分析
需求: 实现斗地主发牌, 特殊要求是看牌时按照从小到大顺序排列
分析:
        准备牌:
                为了牌有大小顺序, 给牌编号, 一个编号对应一张牌: 0=大王, 1=小王, 2=♤2, 3=♤3 ...
                编号和牌是一对一映射关系, 用HashMap<Integer, String>存储, key为编号, value为牌
                再为编号单独创建一个额外的ArrayList<Integer> pokerIndex
                定义编号变量 int index = 0;
                按照编号添加大小王
                嵌套for循环拼接序号和花色, 存入HashMap, 同时将编号存入ArrayList, 编号index++
        洗牌:
                Collections.shuffle(List list)将编号的ArrayList pokerIndex打乱顺序
        发牌:
                创建4个ArrayList, 前3个是玩家, 最后一个是底牌
                遍历编号的ArrayList pokerIndex, 发编号给玩家, >=51时发给底牌
                对4个ArrayList排序
        看牌
                定义方法:
                public static void lookPoker(String name, HashMap<Integer, String> poker, ArrayList<Integer> list)
                        方法内打印姓名, 遍历编号集合ArrayList<Integer> list获取每个编号, 通过编号从HashMap<Integer,String> poker中获取牌, 打印
                调用方法传入 玩家姓名, 牌的Map集合, 玩家集合 来看牌 斗地主案例之发牌看牌代码编写
10分钟练习: 实现斗地主代码:
public class Test {
    public static void main(String[] args) {
        /*
            准备牌
         */
        // 定义花色和数值集合
        List<String> colors = List.of("♤", "♡", "♣", "♢");
        List<String> numbers = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
        // 定义牌盒map
        HashMap<Integer, String> poker = new HashMap<>();
        // 定义牌的序号集合list
        ArrayList<Integer> pokerIndex = new ArrayList<>();        // 定义一个索引作为牌的序号
        int index = 0;
        // 先添加大小王
        poker.put(index, "大王");
        pokerIndex.add(index);
        index++;
        poker.put(index, "大王");
        pokerIndex.add(index);
        index++;        // 然后拼接牌, 并添加
        for (String number : numbers) {
            for (String color : colors) {
                String pai = color + number;
                // 添加到牌盒
                poker.put(index, pai);
                // 添加索引
                pokerIndex.add(index);
                // 增加索引
                index++;
            }
        }        /*
            洗牌
         */
        Collections.shuffle(pokerIndex);        /*
            发牌
         */
        // 创建玩家和底牌集合, 存储序号
        ArrayList<Integer> player01 = new ArrayList<>();
        ArrayList<Integer> player02 = new ArrayList<>();
        ArrayList<Integer> player03 = new ArrayList<>();
        ArrayList<Integer> diPai = new ArrayList<>();
        // 遍历序号集合, 发序号
        for (int i = 0; i < pokerIndex.size(); i++) {
            //取出一个序号
            Integer in = pokerIndex.get(i);
            // 发
            if (i >= 51) {
                diPai.add(in);
            } else if (i % 3 == 0) {
                player01.add(in);
            } else if (i % 3 == 1) {
                player02.add(in);
            } else if (i % 3 == 2) {
                player03.add(in);
            }
        }        /*
            排序
         */
        Collections.sort(player01);
        Collections.sort(player02);
        Collections.sort(player03);
        Collections.sort(diPai);

        /*
            看牌
         */
        lookPoker("刘备", poker, player01);
        lookPoker("关羽", poker, player02);
        lookPoker("张飞", poker, player03);
        lookPoker("底牌", poker, diPai);
    }    // 定义一个方法来看牌
    private static void lookPoker(String name, HashMap<Integer, String> poker, ArrayList<Integer> list) {
        // 先打印玩家名称
        System.out.print(name + ":");
        // 然后遍历序号集合, 通过序号获取map中的牌
        for (Integer key : list) {
            String pai = poker.get(key);
            // 打印牌
            System.out.print(pai + " ");
        }
        // 打印完一个玩家的牌后换行
        System.out.println();
    }
}
今日API
java.util.Map接口: 双列集合的顶层
// 成员方法
V put(K key, V value): 添加/修改 键值对.
如果键存在, 则用新值替换已有值, 返回被替换的值; 如果键不存在, 则添加键值对, 返回null
V remove(Object key): 根据键删除键值对, 返回被删除元素的值
如果键不存在, 返回null
V get(Object key): 根据键获取值.
如果键不存在, 则返回null
boolean containsKey(Object key): 判断是否包含指定的键
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
// JDK 9对于集合初始化的优化
java.util.List
// 静态方法
static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
java.util.Set
// 静态方法
static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
java.util.Map
// 静态方法
static Map<K, V> of(K k1, V v1): 返回包含指定键值对的 不可变Map 集合

Map双列集合总结
Map接口: 双列集合的根接口, 规定了共性的方法
|_ HashMap类: 哈希表=数组+链表+红黑树. key无序不可重复, 可存null键null值, 线程不安全效率高
| |_ LinkedHashMap类: 哈希表+链表. 哈希表实现key不可重复, 链表实现key存取有序
|
|_ Hashtable类: 哈希表. Hash特性针对key, key无序不可重复, 不可存null键null值, 线程安全效率低
|_ TreeMap类: 红黑树结构(存入时就排序). Tree特性针对key, 可以按照key排序, 要求key具备比较性
|_ 遍历
|_ keySet(): 获取所有key组成的Set集合, 遍历Set集合拿到key, 通过Map的get(key)得到value
| |_ 对于Set<Key>的遍历
| |_ 增强for
| |_ 迭代器
|_ entrySet(): 获取所有的key和value组成的Entry对象的Set集合, 遍历出entry对象, 通过
entry对象的getKey()获取对应的key, 通过Entry对象的getValue方法获取对应的value
|_ 对Set<Entry>的遍历
|_ toArray()
|_ 增强for
|_ 迭代器

Map集合特点
1. 一个元素有一个key+一个value
2. key value的类型可以一样, 可以不一样
3. key不能重复
4. 一个key对应一个value
HashMap
key 存取无序
能存null值或null键
LinkedHashMap
key 存取有序

使用Map集合添加方法保存数据
V put(K k, V v)
  如果key不存在, 则添加键值对, 返回null
  如果key存在, 则替换旧值, 返回旧值

使用”键找值”的方式遍历Map集合
keySet()

Set<键> set = map.keySet();
for (键类型 key: set) {
  值 = map.get(key);
}
使用”键值对”的方式遍历Map集合
entrySet()

Set<Map.Entry<键, 值>> set = map.entrySet();
for (Map.Entry<键, 值> entry : set) {
  entry.getKey();
  entry.getValue();
}
能够使用HashMap存储自定义键值对的数据
自定义JavaBean
作key: 重写hashCode() equals()
  作value: 没有要求

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2