Topic18：Map集合

18.01 Map集合概述和特点

• Map接口概述
  • 将键映射到值的对象
  • 一个映射不能包含重复的键
  • 每个键最多只能映射到一个值
• Map接口和Collection接口的不同
  • Map是双列的，Collection是单列的
  • Map的键唯一，Collection的子体系Set是唯一的
  • Map集合的数据结构值针对键有效，跟值无关；Collection集合的数据结构是针对元素有效
  • Set底层依赖Map

18.02 Map集合的功能概述

• 添加功能
  • V Put(K key, V value):添加元素
    • 如果键是第一次存储，就直接存储元素，返回null
    • 如果键不是第一次存储，就用值把以前的值替换掉，返回以前的值。
• 删除功能
  • void clear():移除所有的键值对元素
  • V remove（object key）:根据键删除键值对元素，并把值返回
• 判断功能
  • boolean containsKey(Object key)：判断集合是否包含指定的键
  • boolean containsValue(Object key)：判断集合是否包含指定的值
  • boolean isEmpty():判断集合是否为空
• 获取功能
  • Set<Map.Entry<K,V>> entrySet():
  • V get(Object key):根据键获取值
  • Set<K> keySet():获取集合中所有键的集合
  • Collection<V> values():获取集合中所有值得集合
• 长度功能
  • int size()：返回集合中的键值对的个数

18.03 Map集合的遍历之键找值

• 使用增强for循环
• 在keySet()集合中根据get(key)获得value

18.04 键值对对象找键和值

• 思路
  • 获取所有键值对对象的集合
  • 遍历键值对对象的集合，获取到每一个键值对对象
  • 根据键值对对象找键和值
• Map.Entry说明Entry是Map的内部接口，将键和值封装成了Entry对象，并存储在Set集合中
• Entry是Map的子对象

18.05 HashMap

• HashMap集合键是Student值是String的案例
• 自定义对象重写hashCode和equals方法

18.06 LinkedHashMap的概述和使用

• 底层用链表实现，可以有序排列

18.07 TreeMap集合存取自定义对象

• 自定义对象要实现Comparable接口，实现compareTo方法
• 也可以添加比较器comparator
• 与TreeSet是一个套路

18.08 统计字符串中每个字符出现的次数

• 没有特殊要求，就用hashMap，因为它的效率最高(它是无序的，直接往里面扔)

package com.kevin.test;

import java.util.HashMap;

public class Test1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // 1.定义一个需要被统计的字符串
        String s = "aaaaaaabbbbbccccdddfffff";
        // 2.将字符串转换为字符数组
        char[] arr = s.toCharArray();
        // 3.定义双列集合，存储字符串中字符以及字符出现的次数
        HashMap<Character, Integer> hm = new HashMap<>();
        // 4.遍历字符数组获取每一个字符，并将字符存储在双列集合中
        for (char c : arr) {
            // 5.做判断，如果集合中不包含这个键，就将该字符当做键，值为1存储，如果集合中包含这个键，就将值加1存储
            hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1);
        }
        // 6.打印双列集合获取字符串出现的次数
        for (Character key : hm.keySet()) {
            System.out.println(key + "=" + hm.get(key));
        }
    }

}

18.09 集合嵌套——HashMap嵌套HashMap

• 进行嵌套打印
• for(HashMap<Student, String> h : hm.KeySet())

18.10 HashMap和Hashtable的区别

• Hashtable与Vector很像，现在都被替代掉了
• 共同点
  • 底层都是Hash算法，都是双列集合
• 区别
  • HashMap是线程不安全的，效率高，JDK1.2版本的
  • Hashtable是线程安全的，效率低，JDK1.0版本的
  • HashMap可以存储null键与null值
  • Hashtable不可以存储null键与null值

18.11 Collection工具类的概述和常见方法讲解

• 当一个类中所有的方法都是静态方法，那么就应该私有构造方法，直接类名调用就可以了。
• 所谓的比较，就必须实现compare方法
• Collections中的常见方法
  • sort(List<T> list)
  • binarySearch（二分查找法）
  • max
  • min
  • reverse
  • shuffle：随机置换， 可以用来洗牌

18.12 模拟斗地主洗牌和发牌

• concat：连接两个字符串

package com.kevin.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

public class Test2 {

    /**
     * 分析：
     * 1，买一副扑克，其实就是自己创建一个集合对象，将扑克牌存储进去
     * 2，洗牌
     * 3，发牌
     * 4，看牌
     */
    public static void main(String[] args) {
        // 1.买一副扑克，其实就是自己创建一个集合对象，将扑克牌存储进去
        String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String[] color = {"红桃","黑桃","方块","梅花"};
        ArrayList<String> poker = new ArrayList<>();
        
        //拼接花色和数字
        for (String s1 : color) {
            for (String s2 : num) {
                poker.add(s1.concat(s2));
            }
        }
        
        poker.add("小王");
        poker.add("大王");
        
        // 2.洗牌
        Collections.shuffle(poker);
        
        // 3.发牌
        ArrayList<String> gaojin = new ArrayList<>();
        ArrayList<String> longwu = new ArrayList<>();
        ArrayList<String> me = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        
        for (int i = 0; i < poker.size(); i++) {
            if (i >= poker.size() - 3) {
                dipai.add(poker.get(i));
            } else if(i % 3 == 0){
                gaojin.add(poker.get(i));
            } else if(i % 3 == 1){
                longwu.add(poker.get(i));
            } else {
                me.add(poker.get(i));
            }
        }
        
        // 4.看牌
        System.out.println(gaojin);
        System.out.println(longwu);
        System.out.println(me);
        System.out.println(dipai);
    }

}

18.13 对牌进行重新排序

• 使用HashMap：双列集合

package com.kevin.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class Test3 {

    /**
     * 分析：
     * 1，买一副扑克，其实就是自己创建一个集合对象，将扑克牌存储进去
     * 2，洗牌
     * 3，发牌
     * 4，看牌
     */
    public static void main(String[] args) {
        // 1.买一副扑克，其实就是自己创建一个集合对象，将扑克牌存储进去
        String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2",};
        String[] color = {"红桃","黑桃","方块","梅花"};
        
        // 存储索引和扑克牌
        HashMap<Integer, String> hm = new HashMap<>();
        // 存储索引
        ArrayList<Integer> list = new ArrayList<>();
        int index = 0;
        // 拼接扑克牌并将索引和扑克牌存储在HashMap中
        for (String s1 : num) {                           //获取数字
            for (String s2 : color) {                     //获取颜色
                hm.put(index, s2.concat(s1));
                list.add(index);
                index++;
            }
        }
        // 将小王添加到双列集合中
        hm.put(index, "小王");
        list.add(index);
        index++;
        hm.put(index, "大王");
        list.add(index);
        
        // 2.洗牌
        Collections.shuffle(list);
        
        // 3.发牌
        TreeSet<Integer> gaojin = new TreeSet<>();
        TreeSet<Integer> longwu = new TreeSet<>();
        TreeSet<Integer> me = new TreeSet<>();
        TreeSet<Integer> dipai = new TreeSet<>();
        
        for (int i = 0; i < list.size(); i++) {
            if (i >= list.size() - 3) {
                dipai.add(list.get(i));
            } else if(i % 3 == 0){
                gaojin.add(list.get(i));
            } else if(i % 3 == 1){
                longwu.add(list.get(i));
            } else {
                me.add(list.get(i));
            }
        }
        
        // 4.看牌
        lookPoker(hm, gaojin, "高进");
        lookPoker(hm, longwu, "龙五");
        lookPoker(hm, me, "我");
        lookPoker(hm, dipai, "底牌");
    }

    public static void lookPoker(HashMap<Integer, String> hm,
            TreeSet<Integer> ts, String name) {
        System.out.print(name + "的牌是:");
        for (Integer integer : ts) {
            System.out.print(hm.get(integer) + " ");
        }
        System.out.println();
    }

}

18.14 泛型固定下边界

• 泛型固定上边界（多态的思想，父类指向子类）
  • ？ extends E
• 泛型固定下边界（拿出去做比较，也是多态的思想）
  • ? super E

18.15 集合总结

• Collection体系

  • List（存取有序，有索引，可以重复）
    • ArrayList（底层是数组实现的，线程不安全，查找和修改快，增和删比较慢）
    • LinkedList（底层是链表实现的，线程不安全，增和删比较快，查找和修改比较慢）
    • Vector（底层是数组实现的，线程安全的，无论增删改查都慢）
  • Set （存取无序，无索引，不可以重复）
    • HashSet（底层是哈希算法实现的）
      • LinkedHashSet（底层是链表实现的，但是也是可以保证元素唯一，和HashSet原理一样）
    • TreeSet（底层是二叉树算法实现）

• Map体系

  • HashMap（底层是Hash算法，针对键）
    • LinkedHashMap（底层是链表，针对键）
  • TreeMap（底层是二叉树算法，正对键）

• 开发中常用，ArrayList，HashSet，HashMap，简单高效（开发中一般不需要排序）