[数据结构与算法]Map集合、 HashMap集合、LinkedHashMap集合、Hashtable集合

Map集合

Map集合的特点

Map集合是一个双链表结构的集合，一个元素包含两个值（key，value）
Map集合中的元素，key和value的数据类型可以相同也可以不同
Map集合中的元素，key是不允许重复的，value是可以重复的
Map集合中的元素，key和value是一一对应的

Map接口中的常用方法

     V put(K key, V value)
       将指定的值与此映射中的指定键关联（可选操作）。
     V remove(Object key)
       如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
     V get(Object key)
      返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
     boolean containsKey(Object key)
      如果此映射包含指定键的映射关系，则返回 true。

/**
 * LinkedHashMap集合是一个有序的集合，存储和取出的元素的顺序不一致
 */
private static void demo05() {
    //创建Map集合对象，多态
    HashMap<String, String> map = new HashMap<>();
    map.put("张铭恩", "胡冰卿");
    map.put("马国明", "汤洛雯");
    map.put("李嘉铭", "刘泳希");
    map.put("金瀚", "张芷溪");
    System.out.println(map);
    LinkedHashMap<String, String> map1 = new LinkedHashMap<>();
    map1.put("张铭恩", "胡冰卿");
    map1.put("马国明", "汤洛雯");
    map1.put("李嘉铭", "刘泳希");
    map1.put("金瀚", "张芷溪");
    System.out.println(map1);
}

/**
 * boolean containsKey(Object key)
 *           如果此映射包含指定键的映射关系，则返回 true。
 */
private static void demo04() {
    //创建Map集合对象，多态
    HashMap<String, String> map = new HashMap<>();
    map.put("张铭恩", "胡冰卿");
    map.put("马国明", "汤洛雯");
    map.put("李嘉铭", "刘泳希");
    map.put("金瀚", "张芷溪");
    boolean b = map.containsKey("wang");
    System.out.println(b);
}

/**
 * V get(Object key)
 *           返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
 */
private static void demo03() {
    //创建Map集合对象，多态
    HashMap<String, String> map = new HashMap<>();
    map.put("张铭恩", "胡冰卿");
    map.put("马国明", "汤洛雯");
    map.put("李嘉铭", "刘泳希");
    map.put("金瀚", "张芷溪");
    String s = map.get("马国明");
    System.out.println(s);
}

/**
 * V remove(Object key)
 *            如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
 */
private static void demo02() {
    //创建Map集合对象，多态
    HashMap<String, String> map = new HashMap<>();
    map.put("张铭恩", "胡冰卿");
    map.put("马国明", "汤洛雯");
    map.put("李嘉铭", "刘泳希");
    map.put("金瀚", "张芷溪");
    System.out.println(map);
    String s = map.remove("张铭恩");
    System.out.println(s);
    System.out.println(map);
}

/**
 * V put(K key, V value)
 *            将指定的值与此映射中的指定键关联（可选操作）。
 */
private static void demo01() {
    //创建Map集合对象，多态
    HashMap<String, String> map = new HashMap<>();
    String s = map.put("王", "红");
    System.out.println(s);
}

map集合的遍历

keySet()

keySet的方法

 V get(Object key)
          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
    Set<K> keySet()
          返回此映射中包含的键的 Set 视图。
    

实现步骤：
使用map集合中的方法keySet（），把map集合中所有的key取出来，存储到一个Set集合中
遍历set集合，获取Map集合中的每一个key
通过map集合中的方法get，通过key找到value

public static void main(String[] args) {
    //创建Map集合对象，多态
    HashMap<String, String> map = new HashMap<>();
    map.put("张铭恩", "胡冰卿");
    map.put("马国明", "汤洛雯");
    map.put("李嘉铭", "刘泳希");
    map.put("金瀚", "张芷溪");
    //使用map集合中的方法keySet（），把map集合中所有的key取出来，存储到一个Set集合中
    Set<String> set = map.keySet();
    //遍历set集合，获取Map集合中的每一个key
    //通过map集合中的方法get，通过key找到value
    for (String s : set) {
        String s1 = map.get(s);
        System.out.println(s1);
    }
    System.out.println("****************");
    Iterator<String> iterator = set.iterator();
    while (iterator.hasNext()){
        String s = map.get(iterator.next());
        System.out.println(s);
    }
}

Entry对象中的方法遍历

map集合遍历的第二种方式：使用entry对象遍历

map集合中的方法：
     Set<Map.Entry<K,V>> entrySet()
      返回此映射中包含的映射关系的 Set 视图。

实现步骤：
1.使用map集合中的方法entrySet（），把Map集合中多个Entry对象取出来，存到一个set集合中
2.遍历set集合，获取每一个Entry对象
3.使用Entry对象中的方法遍历getKey（）和getValue（）获取对象的键与值

public static void main(String[] args) {
    //创建Map集合对象，多态
    HashMap<String, String> map = new HashMap<>();
    map.put("张铭恩", "胡冰卿");
    map.put("马国明", "汤洛雯");
    map.put("李嘉铭", "刘泳希");
    map.put("金瀚", "张芷溪");
    //使用map集合中的方法entrySet（），把Map集合中多个Entry对象取出来，存到一个set集合中
    Set<Map.Entry<String, String>> entries = map.entrySet();
    //遍历set集合，获取每一个Entry对象
    //使用Entry对象中的方法遍历getKey（）和getValue（）获取对象的键与值
    Iterator<Map.Entry<String, String>> iterator = entries.iterator();
    while (iterator.hasNext()){
        String keys = iterator.next().getKey();
        String values = map.get(keys);
        System.out.println(keys+"="+values);
    }
}

HashMap集合的特点：

HashMap集合底层是哈希表：查询的速度特别快
? JDK1.8之前：数组+单向链表
? Jdk1.8之后：数组+单向链表/红黑数（链的长度超过8）：提高查询效率
是一个无序集合，存储元素和取出元素的顺序有可能不一致

HashMap存储自定义类型的键值

public static void main(String[] args) {
    demo02();
}
/**
 * HashMap存储自定义类型的键值
 * key：Person类型
 *      Person类型重写hashCode方法和equals方法，可以保证key唯一（同名同年龄视为同一个）
 * value：String类型
 *      value可以重复（同名同年龄视为同一个）
 */
private static void demo02() {
    HashMap<Person,String> map = new HashMap<>();
    map.put(new Person(1970,"孙红雷"),"哈尔滨");
    map.put(new Person(2014,"张艺兴"),"中国");
    map.put(new Person(754,"刘奕君"),"中国");
    map.put(new Person(2014,"张艺兴"),"上海");
    System.out.println(map);
    //没有重写hashCode equals方法前
    //{Person{age=754, name='刘奕君'}=中国, Person{age=2014, name='张艺兴'}=中国, Person{age=1970, name='孙红雷'}=哈尔滨, Person{age=190, name='吴越'}=上海}
    //之后
    //{Person{age=754, name='刘奕君'}=中国, Person{age=2014, name='张艺兴'}=上海, Person{age=1970, name='孙红雷'}=哈尔滨}
}

/**
 * HashMap存储自定义类型的键值
 * key：String类型
 *      String类重写hashCode方法和equals方法，可以保证key唯一
 * value：Person类型
 *      value可以重复（同名同年龄视为同一个）
 */
private static void demo01() {
    HashMap<String, Person> map = new HashMap<>();
    map.put("哈尔滨",new Person(1970,"孙红雷"));
    map.put("中国",new Person(2014,"张艺兴"));
    map.put("中国",new Person(754,"刘奕君"));
    map.put("上海",new Person(190,"吴越"));
    System.out.println(map);
    //{上海=Person{age=190, name='吴越'}, 哈尔滨=Person{age=1970, name='孙红雷'}, 中国=Person{age=754, name='刘奕君'}}
}

LinkedHashMap特点

LinkedHashMap集合底层是哈希表+链表（保证迭代顺序）
?LinkedHashMap集合是一个有序的集合，存储和取出的元素的顺序一致

Hashtable集合

Hashtable：底层也是一个哈希表，是一个线程安全的集合，是单线程的集合，速度慢
HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快

HasoMap集合可以存储NULL值
Hashtable集合不可以

Hashtable和Vector集合一样，在jdk1.2版本后被取代了
HashTable的子类Properties依然活跃在历史的舞台
Properties集合是一个唯一和IO流集合的集合

练习

计算一个字符串中每个元素出现的次数

分析：

使用Scanner获取用户输入的字符串
创建Map集合，key是字符串中的字符，value是字符串的个数
遍历字符串，获取每一个字符
使用获取到的字符，去Map集合判断key是否存在
key存在：
通过字符（key），获取value（字符个数）
value++
key不存在
put（key，1）
遍历Map集合，输出结果

第一种

public static void main(String[] args) {
    //使用Scanner获取用户输入的字符串
    System.out.println("请输入字符串");
    Scanner scanner = new Scanner(System.in);
    String s = scanner.next();
    System.out.println("您输入的字符串是："+s);
    //创建Map集合，key是字符串中的字符，value是字符串的个数
    HashMap<Character, Integer> map = new HashMap<>();
    //遍历字符串，获取每一个字符
    /*
    使用获取到的字符，去Map集合判断key是否存在
        key存在：
           通过字符（key），获取value（字符个数）
           value++
        key不存在
           put（key，1）

     */
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        Integer integer = map.get(c);
        if(integer != null){
            ++integer;
            map.put(c,integer);
        }else {
            map.put(c,1);
        }
    }
  //遍历Map集合，输出结果
    Set<Map.Entry<Character, Integer>> entries = map.entrySet();
    Iterator<Map.Entry<Character, Integer>> iterator = entries.iterator();
    while (iterator.hasNext()){
        Character key = iterator.next().getKey();
        Integer integer = map.get(key);
        System.out.println(key +"数量"+integer);
    }
}

第二种

public static void main(String[] args) {
    //使用Scanner获取用户输入的字符串
    System.out.println("请输入字符串");
    Scanner scanner = new Scanner(System.in);
    String s = scanner.next();
    System.out.println("您输入的字符串是："+s);
    //创建Map集合，key是字符串中的字符，value是字符串的个数
    HashMap<Character, Integer> map = new HashMap<>();
    //遍历字符串，获取每一个字符
    /*
    使用获取到的字符，去Map集合判断key是否存在
        key存在：
           通过字符（key），获取value（字符个数）
           value++
        key不存在
           put（key，1）

     */
    for (char c : s.toCharArray()) {
        if (map.containsKey(c)){
            Integer integer = map.get(c);
            ++integer;
            map.put(c,integer);
        }else {
            map.put(c,1);
        }
    }
  //遍历Map集合，输出结果
    Set<Character> set = map.keySet();
    for (Character character : set) {
        Integer integer = map.get(character);
        System.out.println(character +"数量"+integer);
    }
}

斗地主进阶版

public static void main(String[] args) {
    //构建扑克牌
    //大王 小王 完成
    //其他牌 定义两个数组
    //一个存放四种牌 一个存放牌数
    String[] types = {"?","?","?","?"};
    String[] brand = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
    //创建存放容器
    HashMap<Integer, String> poke = new HashMap<>();
    //存放poke的key值
    ArrayList<Integer> suoyin = new ArrayList<>();
    //存牌
    int key = 0;
    poke.put(key,"大王");
    suoyin.add(key);
    ++key;
    poke.put(key,"小王");
    suoyin.add(key);
    ++key;
    for (String s : brand) {
        for (String type : types) {
            poke.put(key,type+s);
            suoyin.add(key);
            ++key;
        }
    }
    System.out.println(poke);
    System.out.println(suoyin);
    //洗牌
    Collections.shuffle(suoyin);
    System.out.println(suoyin);
    //创建用户
    ArrayList<Integer> paly01 = new ArrayList<>();
    ArrayList<Integer> paly02 = new ArrayList<>();
    ArrayList<Integer> paly03 = new ArrayList<>();
    ArrayList<Integer> dipai = new ArrayList<>();
    //发牌
    for (int i = 0; i < suoyin.size(); i++) {
        if (i > 50){
            dipai.add(suoyin.get(i));
        }else if (i%3 == 0){
            paly01.add(suoyin.get(i));
        }else if (i%3 == 1){
            paly02.add(suoyin.get(i));
        }else if (i%3 == 2){
            paly03.add(suoyin.get(i));
        }
    }
    //查看牌
    demo("我",paly01,poke);
    demo("你",paly02,poke);
    demo("他",paly03,poke);
    demo("底牌",dipai,poke);

}

private static void demo(String name, ArrayList<Integer> paly, HashMap<Integer, String> poke) {
    Collections.sort(paly);
    System.out.print(name + "的牌是：");
    for (Integer integer : paly) {
        String s = poke.get(integer);
        System.out.print(" "+ s);
    }
    System.out.println();
}