Java Day15

第一章 Map集合

1.1 概述

我们通过查看Map接口描述，发现Map接口下的集合Collection接口下的集合，他们存储数据的形式不同，如下图：

• Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。
• Map中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键与值两个部分组成，通过键可以找所对应的值。
• Collection中的集合称为单列集合，Map中的集合称为双列集合。
• 需要我们注意的是：Map中的集合不能包含重复的键，值可以重复，每个键只能对应一个值。

1.2 Map的常用子类

通过查看Map接口描述，看到Map有多个子类，我们主要学HashMap集合，LinkedHashMap集合。

• HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一，不重复，需要重写键的hashCode()，equals()方法。
• LinkedHashMap：HashMap下有一个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素存取的顺序一致；通过哈希表结构可以保证键的唯一，不重复，需要重写键的hashCode方法，equals方法。

1.3 Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

• public V put(K key, V value)：把指定的键与指定的值添加到Map集合中。
• public V remove(Object key)：把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
• public V get(Object key)：根据指定的键，在Map集合中获取对应的值。
• public Set<K> keySet()：获取Map集合中所有的键，存储到Set集合。
• public Set<Map.Entry<K, V>> entrySet()：获取到Map集合中所有的键值对对象的集合。
• 代码如下：

package com.it.day04code.Map;

/*
* java.util.Map<k, v>集合
* Map集合的特点：
*   1、Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）
*   2、Map结婚中的元素，key和value的数据类型可以相同，也可以不同。
*   3、Map集合中的元素，key是不允许重复的，value是可以重复的。
*   4、Map集合中的元素，key和value是一一对应。
* java.util.HashMap<k, v>集合 implements Map<k, v>接口
* HashMap集合的特点：
*   1、HashMap集合底层是哈希表：查询速度非常快。
*       JDK1.8之前：数组+单向链表
*       JDK1.8之后：数组+单向链表/红黑树，提高查询速度
*   2、hashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致。
* java.util.LinkedHashMap<k, v>集合 extends HashMap<k, v>集合
* LinkedHashMap特点：
*   1、LinkedHashMap结婚底层是哈希表+链表（保证了迭代的顺序）
*   2、LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的。
*
* */

import java.util.HashMap;
import java.util.Map;

public class Demo01Map {
    public static void main(String[] args) {
        // show01();
        // show02();
        // show03();
        show04();
    }

    /*
    * boolean containsKey(Object key) 判断集合中是否包含指定的键。
    *   包含返回true，不包含返回false
    *
    * */
    private static void show04() {
        // 创建Map集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志玲", 178);
        System.out.println(map);

        boolean v1 = map.containsKey("赵丽颖");
        System.out.println("v1:" + v1);

        boolean v2 = map.containsKey("tiger");
        System.out.println("v2:" + v2);
    }


    /*
    * public V get(Object key) 根据指定的键，在Map集合中获得对应的值
    *   返回值：
    *       key存在返回对应的值
    *       key不存在返回null
    *
    * */
    private static void show03() {
        // 创建Map集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志玲", 178);
        System.out.println(map);

        Integer v1 = map.get("杨颖");
        System.out.println("v1:" + v1);

        Integer v2 = map.get("tiger");
        System.out.println("v2:" + v2);
    }

    /*
    * public V remove(Object key)：把指定的键所对应的键值对元素在map集合中删除，返回被删除元素的值
    *   返回值：V
    *       key存在返回被删除的值
    *       key不存在返回null
    *
    *
    * */
    private static void show02() {
        // 创建Map集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志玲", 178);
        System.out.println(map);

        Integer v1 = map.remove("林志玲");
        System.out.println("v1:" + v1);
        System.out.println(map);

        Integer v2 = map.remove("tiger");
        System.out.println("v2:" + v2);
        System.out.println(map);
    }

    /*
    * public V put(K key, V value)：把指定的键与指定的值添加到Map集合中。
    *   返回值：v
    *       存储键值对的时候，key不重复，返回值v是null
    *       存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回值是被替换的value值
    * */
    private static void show01() {
        // 创建Map集合对象，多态
        Map<String, String> map = new HashMap<>();
        String v1 = map.put("tiger", "trony1");
        System.out.println("v1:" + v1);

        String v2 = map.put("tiger", "trony2");
        System.out.println("v2:" + v2);

        System.out.println(map);

        map.put("冷锋", "龙小云");
        map.put("杨过", "小龙女");
        map.put("尹志平", "小龙女");
        System.out.println(map);
    }

}

注意：使用put方法时，若指定的键（key）在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中。若指定的键在集合中存在，则返回值为集合中键对应的值，并把指定键所对应的值，替换成为新值。

1.4 Map集合遍历键找值的方式

• 键找值的方式：即通过元素中的键，获取键所对应的值。
• 分析步骤：
  • 获取Map中的所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键，方法提示：keySet()
  • 遍历键的Set集合，得到每一个键。
  • 根据键，获取键所对应的值，方法提示：get(K key)

package com.it.day04code.Map;

/*
* Map集合中的第一种遍历方式：通过键找值的方式
* Map集合中的方法：
*   Set<K> keySet() 返回此映射中包含的键的set视图
* 实现步骤：
*   1、使用Map集合中的方法keySet()，把Map集合所有的key取出来，存储到一个set集合中
*   2、遍历set集合，获取Map集合中每一个key
*   3、通过Map集合中的方法get(key)，通过key找到value
*
* */

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo02KeySet {
    public static void main(String[] args) {
        // 创建Map集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志玲", 178);
        System.out.println(map);

        // 使用Map集合中的方法keySet()，把Map集合所有的key取出来，存储到一个set集合中
        Set<String> set = map.keySet();

        // 遍历set集合，获取Map集合中每一个key
        // 使用迭代器遍历Set集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(map.get(it.next()));
        }

        System.out.println("=======================");

        // 使用增强for遍历set集合
        for (String name : set) {
            System.out.println(map.get(name));
        }


    }
}

1.5 Entry键值对对象

在之前我们可以看到，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在Map中是一一对应关系，这一对对对象又称作Map中的一个Entry（项）。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合的时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

• 既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值的方法：
  • public E getKey()：获取Entry对象中的键。
  • public V getValue()：获取Entry对象中的值。
• 在Map集合中获取所有Entry对象的方法：
  • public Set<Map.Entry<K, V>> entrySet()：获取到Map集合中所有的键值对对象的集合。

1.6 Map集合遍历键值对方式

• 键值对方式：即通过集合中每个键值对对象，获取键值对对象中的键与值。
• 操作步骤：
  • 获取Map集合中，所有的键值对对象，以set集合形式返回，方法提示：entrySet()
  • 遍历包含键值对对象的Set结合，得到每一个键值对对象。
  • 通过键值对对象，获取Entry对象中的键与值，方法提示：getKey()，getValue()
• 代码如下：

package com.it.day04code.Map;

/*
* map集合遍历的第二种方式：
*   Map集合中的方法：
*       Set<Map.Entry<K, V>> entrySet() 返回此映射中包含的映射关系的set视图
*
* 实现步骤：
*   1、使用map集合中的方法entrySet()，把Map结婚中多个Entry对象取出来，存储到一个Set集合中
*   2、遍历Set集合，获取每一个Entry对象
*   3、使用Entry对象中的方法getKey()和getValue()获取键与值
*
* */

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo03EntrySet {
    public static void main(String[] args) {
        // 创建Map集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("杨颖", 165);
        map.put("林志玲", 178);
        System.out.println(map);

        // 使用map集合中的方法entrySet()，把Map结婚中多个Entry对象取出来，存储到一个Set集合中
        Set<Map.Entry<String, Integer>> set = map.entrySet();

        // 遍历Set集合，获取每一个Entry对象
        // 使用迭代器遍历Set集合
        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }

        System.out.println("=====================");

        // 使用增强for循环遍历
        for (Map.Entry<String, Integer> entry : set) {
            System.out.println(entry.getKey() + "=" + entry.getValue());

        }

    }
}

1.7 HashMap存储自定义类型键值

编写类：

package com.it.day04code.HashMap;

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

编写测试类：

package com.it.day04code.HashMap;

/*
* HashMap存储自定义类型键值
* Map集合保证key是唯一的：
*   作为key的元素必须要重写hashCode方法和equals方法，以保证key唯一
*
* */

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo01HashMapSavePerson {
    public static void main(String[] args) {
        // show01();
        show02();

    }

    /*
    * HashMap存储自定义类型键值
    * key：Person类型
    *   Person类就必须重写hashCode方法和equals方法，以保证key唯一
    * value：String类型
    *   value可以重复
    *
    * */
    private static void show02() {
        // 创建一个HashMap集合
        HashMap<Person, String> map = new HashMap<>();

        // 往集合中添加元素
        map.put(new Person("女王", 18), "英国");
        map.put(new Person("秦始皇", 18), "秦国");
        map.put(new Person("普京", 18), "俄罗斯");
        map.put(new Person("女王", 18), "毛里求斯");

        // 使用entrySet和增强for遍历Map集合
        Set<Map.Entry<Person, String>> set = map.entrySet();
        for (Map.Entry<Person, String> entry : set) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }


    }

    /*
    * HashMap存储自定义类型键值
    * key：String类型
    *      String类重写hashCode方法和equals方法，可以保证key唯一
    *
    *      value：Person类型
    *             value可以重复(同名同年龄视为同一个人)
    *
    * */
    private static void show01() {
        // 创建HashMap集合
        HashMap<String, Person> map = new HashMap<>();

        // 往集合中添加元素
        map.put("北京", new Person("张三", 18));
        map.put("上海", new Person("李四", 19));
        map.put("广州", new Person("王五", 20));
        map.put("北京", new Person("赵六", 18));

        // 使用keySet加增强for遍历Map集合
        Set<String> set = map.keySet();
        for(String key : set) {
            System.out.println(key + "-->" + map.get(key));
        }


    }


}

• 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须重写对象的hashCode和equals方法。
• 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap。

1.8 LinkedHashMap

在前面我们学到HashMap保证成对元素的唯一，并且查询速度很快，可是对成对元素存放进去是没有顺序的，那么我们要保证有序，就可以使用LinkedHashMap子类，它是一个链表和哈希表的一个数据存储结构。代码如下：

package com.it.day04code.LinkedHashMap;

/*
* java.util.LinkedHashMap<K, V> extends HashMap<K, V>
* Map接口的哈希表和链表实现，具有可预知的迭代顺序
* 底层原理：
*   哈希表+链表（记录元素的顺序）
* */

import java.util.HashMap;
import java.util.LinkedHashMap;

public class Demo01LinkedHashMap {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put("a", "a");
        map.put("c", "c");
        map.put("b", "b");
        map.put("d", "d");
        System.out.println(map);  // key值不允许重复，无序

        LinkedHashMap<String, String> linked = new LinkedHashMap<>();
        linked.put("a", "a");
        linked.put("c", "c");
        linked.put("b", "b");
        linked.put("d", "d");
        System.out.println(linked);  // key不允许重复，有序的集合

    }
}

1.9 Map集合练习

需求： 计算一个字符串中每个字符出现次数。

import java.util.HashMap;
import java.util.Scanner;

public class Demo01Main {
    public static void main(String[] args) {
        HashMap<Character, Integer> map = new HashMap<>();
        System.out.println("请输入一个字符串：");
        String input = new Scanner(System.in).next();
        char[] chars = input.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];
            if (map.containsKey(ch)) {
                Integer integer = map.get(ch);
                integer += 1;
                map.put(ch, integer);
            } else {
                map.put(ch, 1);
            }
        }
        System.out.println(map);
    }
}

第二章 补充知识点

2.1 JDK9对集合添加的优化

通常我们在代码中创建一个集合，并且直接用一些元素来填充它，实力化集合，集合add方法重复使用，在JDK9中，添加了集中集合工厂方法，用来方便我们创建少量元素的集合，map实例。代码如下：

/*
* JDK的新特性：
*   List接口，Set接口，Map接口：里面增加了一个静态方法of，可以一次性的添加多个元素
*   static <E> List<E> of (E... element)
*   使用前提：当集合中存储的元素的个数已经确定了，不再改变时使用
* 注意：
*   1、of方法只适用于List接口，Set接口，Map接口，不适用于接口的实现类。
*   2、of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法添加元素，会抛出异常。
*   3、Set接口和Map接口在调用of方法的时候，不能有重复元素，否则会抛出异常
*
* */


import java.util.List;
import java.util.Map;
import java.util.Set;

public class Demo01JDK9 {
    public static void main(String[] args) {
        List<String> list = List.of("a", "b", "c", "d");
        System.out.println(list);
        // list.add("w");  // UnsupportedOperationException：不支持操作异常

        // Set<String> set = Set.of("a", "b", "c", "d", "a");  // IllegalArgumentException：非法参数异常
        // System.out.println(set);

        Map<String, Integer> map = Map.of("张三", 18, "李四", 19);
        System.out.println(map);
        // map.put("赵四", 20);  // UnsupportedOperationException
    }
}

第三章 斗地主案例重写

需求我们之前讲过，这里用map重写一下该案例：

package com.it.day04code.FightLord;

import java.util.*;

public class Demo01Main {
    public static void main(String[] args) {
        List<String> color = List.of("♥️", "♦️", "♠️", "♣️");
        List<String> no = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
        List<String> card = new ArrayList<>();
        for (int i = 0; i < color.size(); i++) {
            for (int i1 = 0; i1 < no.size(); i1++) {
                String str = color.get(i) + no.get(i1);
                card.add(str);
            }
        }
        Map<Integer, String> cards = new HashMap<>();
        for (int i = 0; i < 54; i++) {
            if (i == 0) {
                cards.put(i, "大王");
            } else if (i == 1) {
                cards.put(i, "小王");
            } else {
                cards.put(i, card.get(i - 2));
            }
        }
        List<Integer> index = new ArrayList<>();
        for (int i = 0; i < 54; i++) {
            index.add(i);
        }
        Collections.shuffle(index);

        ArrayList<Integer> p1 = new ArrayList<>();
        ArrayList<Integer> p2 = new ArrayList<>();
        ArrayList<Integer> p3 = new ArrayList<>();
        ArrayList<Integer> dipai = new ArrayList<>();

        for (int i = 0; i < index.size(); i++) {
            if (i > 50) {
                dipai.add(index.get(i));
            } else if (i % 3 == 0) {
                p1.add(index.get(i));
            } else if (i % 3 == 1) {
                p2.add(index.get(i));
            } else if (i % 3 == 2) {
                p3.add(index.get(i));
            }
        }
        Collections.sort(p1);
        Collections.sort(p2);
        Collections.sort(p3);
        Collections.sort(dipai);


        for (int i = 0; i < p1.size(); i++) {
            if (i == 0) {
                System.out.printf("p1:");
            }
            System.out.printf(cards.get(p1.get(i)) + " ");
        }

        for (int i = 0; i < p2.size(); i++) {
            if (i == 0) {
                System.out.printf("\np2:");
            }
            System.out.printf(cards.get(p2.get(i)) + " ");
        }

        for (int i = 0; i < p3.size(); i++) {
            if (i == 0) {
                System.out.printf("\np3:");
            }
            System.out.printf(cards.get(p3.get(i)) + " ");
        }

        for (int i = 0; i < dipai.size(); i++) {
            if (i == 0) {
                System.out.printf("\ndipai：");
            }
            System.out.printf(cards.get(dipai.get(i)) + " ");
        }

    }
}