Java-Map，斗地主案例-第15节-CSDN博客

本文链接：https://blog.csdn.net/zuefeng/article/details/108628619

学习目标：

学会使用Map集合接口；
能够熟练使用接口中的方法。

学习内容：

一、Map集合接口

1、简介

双列集合
键值对（键唯一，值可以重复，一个键对应一个值，成对存在，通过键能够找到对应的值）
java.util.Map

2、特点

一个元素包括key，value两个值
key和value数据类型可以相同也可以不同
key不可以重复，value可以重复
key，value一一对应

3、Map常用实现类

HashMap
- 特点
  - 允许null键和值
  - 多线程
  - 底层是哈希表
  - 无序的集合
LinkedHashMap
- 特点
  - 底层是哈希表+链表（保证迭代顺序）
  - 有序的集合
HashTable
- 特点
  - 不允许null键和值
  - 最早的双列集合
  - 单线程（速度慢）
  - 底层是哈希表
  - 无序的集合
- PS：
  - 子类Propreties依然活跃在历史舞台
  - 该子类是唯一一个和IO流相结合的集合

4、常用方法

put方法
- 将指定的键与值添加到集合中，返回被替换的值
- public V put(K key,V value);
- 返回值规则：
  - 存储数据时，key不重复，返回null
  - 存储数据时，key重复，新值覆盖原值，返回原值（被替换的值）
get方法
- 获取指定的键对应的键值对元素对应的值
- public V get(K key);
- 返回值规则：
  - 获取数据时，key不存在，返回null
  - 获取数据时，key存在，返回对应的值
remove方法
- 将指定的键值对从集合中删除，并返回删除元素的值
- public V remove(K key);
- 返回值规则：
  - 删除数据时，key存在，返回对应value值
  - 删除数据时，key不存在，返回null
containsKey方法
- 判断集合中是否包含指定的键
- public boolean containsKey(K key);
- 返回值规则：
  - 包含该key时，返回true
  - 不包含该key时，返回false

5、遍历Map集合的方法

keySet方法
- 获取Map集合中的所有键的集合
- public Set keySet();
- 遍历步骤：
  - 先通过此方法获取所有的键；
  - 然后用迭代的方法遍历所有的键；
  - 通过Map.get方法获取对应的值
entrySet方法
- 获取Map集合中的所有键值对对象entrySet的集合
- public Entry<K,V> entrySet();
- 遍历步骤：
  - 先通过此方法获取所有的Entry对象
  - 然后遍历Entry对象
  - 最后通过Entry的getKey与getValue方法获取对应元素的键与值

6、传递自定义的键或值

自定义类型的键
- 自定义的类型要重写equals与hashCode方法，保证键唯一
自定义类型的值
- 对值无特殊要求

二、JDK9新特性

1、List、Set、Map接口，里边增加一个静态方法of，可以给集合一次性添加多个元素

static List of(E… elements);

2、使用前提

集合中存储元素个数确定，不再改变时使用
PS：
- of方法只适用于上述3个接口，不适用于接口的实现类
- of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法添加元素，会抛出异常
- Set与Map接口在使用of方法时，不能有重复元素，否则会抛出异常

学习产出：

1、Map接口方法

package mypackage.day11.demo01;

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

public class DemoMapMethod {
    public static void main(String[] args) {
        tianjia();
        shanchu();
        huoqu();
        panduan();
    }

    private static void panduan() {
        System.out.println("=======判断元素是否存在========");
        Map<String, String> hashMap = new HashMap<>();
        String v1 = hashMap.put("Jim","Tom");
        String v2 = hashMap.put("Smith","Mary");
        String v3 = hashMap.put("Harry","Lily");
        boolean containsKey = hashMap.containsKey("Smith");
        System.out.println("判断Smith结果："+containsKey);
        boolean containsKey1 = hashMap.containsKey("dashduak");
        System.out.println("判断dashduak结果："+containsKey1);
    }

    private static void huoqu() {
        System.out.println("=======获取元素========");
        Map<String, String> hashMap = new HashMap<>();
        String v1 = hashMap.put("Jim","Tom");
        String v2 = hashMap.put("Smith","Mary");
        String v3 = hashMap.put("Harry","Lily");
        String s = hashMap.get("Harry");
        System.out.println("获取到的元素的值："+s);
    }

    private static void shanchu() {
        System.out.println("=======删除键值对========");
        Map<String, String> hashMap = new HashMap<>();
        String v1 = hashMap.put("Jim","Tom");
        String v2 = hashMap.put("Smith","Mary");
        String v3 = hashMap.put("Harry","Lily");
        System.out.println("移除元素前的集合："+hashMap);
        String s = hashMap.remove("Smith");
        System.out.println("移除的元素的值："+s);
        System.out.println("移除元素后的集合："+hashMap);

    }

    private static void tianjia() {
        System.out.println("=========添加键值对=========");
        Map<String, String> hashMap = new HashMap<>();

        String v1 = hashMap.put("Jim","Tom");
        System.out.println("添加新key元素返回的值："+v1);
        String v2 = hashMap.put("Jim","Mary");
        System.out.println("添加已有key返回的值："+v2);
        System.out.println("最终的集合值："+hashMap);
    }
}

2、遍历循环Map集合

package mypackage.day11.demo01;

//用接口中的方法辅助遍历循环Map集合

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

public class DemoMapQuery {
    public static void main(String[] args) {
        bianli1();
        bianli2();
    }

    private static void bianli2() {
        System.out.println("==========entrySet方法===========");
        Map<String, String> hashMap = new HashMap<>();
        String v1 = hashMap.put("Jim","Tom");
        String v2 = hashMap.put("Smith","Mary");
        String v3 = hashMap.put("Harry","Lily");
        Set<Map.Entry<String, String>> entries = hashMap.entrySet();
        System.out.println("------迭代器方法--------");
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, String> entry = iterator.next();
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
        System.out.println("------增强for方法--------");
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }

    private static void bianli1() {
        System.out.println("==========keySet方法===========");
        Map<String, String> hashMap = new HashMap<>();
        String v1 = hashMap.put("Jim","Tom");
        String v2 = hashMap.put("Smith","Mary");
        String v3 = hashMap.put("Harry","Lily");
        Set<String> keySet = hashMap.keySet();
        System.out.println("------迭代器方法--------");
        Iterator<String> iterator = keySet.iterator();
        while (iterator.hasNext()){
            String key = iterator.next();
            System.out.println(hashMap.get(key));
        }
        System.out.println("------增强for方法--------");
        for (String key : keySet) {
            System.out.println(hashMap.get(key));
        }
    }
}

3、向Map集合中传递自定义类型

package mypackage.day11.demo01;

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

    // 自定义equals和hashCode方法，保证key值唯一
    @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);
    }

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

package mypackage.day11.demo01;

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

public class DemoMapDefineBySelf {
    public static void main(String[] args) {
        definekey();
        definevalue();
    }

    private static void definevalue() {
        System.out.println("=========自定义value值=========");
        HashMap<String,Person> hashMap = new HashMap<>();
        hashMap.put("English",new Person("Jim",18));
        hashMap.put("America",new Person("Tom",28));
        hashMap.put("China",new Person("Mary",18));
        hashMap.put("French",new Person("Jim",18));
        Set<Map.Entry<String,Person >> entries = hashMap.entrySet();
        for (Map.Entry<String, Person > entry : entries) {
            System.out.println(entry.getKey()+":"+entry.getValue().getName());
        }
    }

    private static void definekey() {
        System.out.println("=========自定义键值=========");
        HashMap<Person, String> hashMap = new HashMap<>();
        hashMap.put(new Person("Jim",18),"English");
        hashMap.put(new Person("Tom",28),"America");
        hashMap.put(new Person("Mary",18),"China");
        hashMap.put(new Person("Jim",18),"French");
        Set<Map.Entry<Person, String>> entries = hashMap.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            System.out.println(entry.getKey().getName()+":"+entry.getValue());
        }
    }
}

4、练习：计算一个字符串中每个字符出现的次数。
在这里插入图片描述

package mypackage.day11.demo02;

/*
    要求：
        计算一个字符串中每个字符出现的次数。
    思路：
        1、使用Scanner让用户输入一个字符串；
        2、创建Map集合，key是字符串的字符，value是字符个数；
        2、遍历字符串，获取每一个字符；
        3、使用Map集合中的方法判断集合中是否存在该字符：
            若存在该字符，将对应的个数value++
            若不存在该字符，将该字符添加Map集合
        4、遍历Map集合并输出结果
*/

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

public class DemoMapTrain {
    public static void main(String[] args) {
        // 获取用户输入的字符串
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String s = scanner.next();

        // 建立hashMap集合
        HashMap<Character, Integer> hashMap = new HashMap<>();

        // 遍历字符串，并进行判断添加
        char[] array = s.toCharArray();
        for (char c : array) {
            if (hashMap.containsKey(c)){
                int value = hashMap.get(c);
                Integer put = hashMap.put(c, ++value);
            }else {
                Integer put = hashMap.put(c, 1);
            }
        }

        // 遍历集合，输出结果
        System.out.println("========输出结果============");
        Set<Map.Entry<Character, Integer>> entries = hashMap.entrySet();
        for (Map.Entry<Character, Integer> entry : entries) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
}

5、java9新特性----of方法

package mypackage.day11.demo03;

// java9新特性----of方法

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

public class DemoJava09Of {
    public static void main(String[] args) {
        System.out.println("========List========");
        List<String> list = List.of("Jim","Tom","Mary","Tom");
        // list.add("Smith");
        System.out.println(list);

        System.out.println("========Set========");
        Set<String> set = Set.of("Jim","Tom","Mary");   // ,"Tom"
        // set.add("Smith");
        System.out.println(set);

        System.out.println("========Map========");
        Map<String,Integer> map = Map.of("Jim",17,
                "Tom",21,"Mary",11);   // ,"Tom"
        // map.put("Smith",99);
        System.out.println(map);
    }
}

6、斗地主案例
在这里插入图片描述

package mypackage.day11.demo04;

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

public class DemoBeatDiZhu {
    public static void main(String[] args) {
        // 准备牌
        HashMap<Integer,String> puke = new HashMap<>();
        List<Integer> pukeindex = new ArrayList<>();
        List<String> color = List.of("红桃", "黑桃", "方片", "花子");
        List<String> number = List.of("2","A","K","Q","J","10","9",
                 "8","7","6","5","4","3");

        int index = 0;
        puke.put(index,"大王");
        pukeindex.add(index);
        index++;
        puke.put(index,"小王");
        pukeindex.add(index);
        index++;
        for (String s : number) {
            for (String s1 : color) {
                puke.put(index,s1+s);
                pukeindex.add(index);
                index++;
            }
        }

        // 洗牌
        Collections.shuffle(pukeindex);

        // 发牌
        ArrayList<Integer> player1 = new ArrayList<>();
        ArrayList<Integer> player2 = new ArrayList<>();
        ArrayList<Integer> player3 = new ArrayList<>();
        ArrayList<Integer> remain = new ArrayList<>();
        for (int i = 0; i < pukeindex.size(); i++) {
            if (i>=51){
                remain.add(pukeindex.get(i));
            }else if (i%3==0){
                player1.add(pukeindex.get(i));
            }else if (i%3==1){
                player2.add(pukeindex.get(i));
            }else if (i%3==2){
                player3.add(pukeindex.get(i));
            }
        }

        // 看牌
        show("Jim",puke,player1);
        show("Tom",puke,player2);
        show("Mary",puke,player3);
        show("DiPai",puke,remain);
    }

    private static void show(String name, HashMap<Integer, String> puke, ArrayList<Integer> player1) {
        Collections.sort(player1);
        System.out.println("\n"+name+": ");
        for (Integer index : player1) {
            System.out.print(puke.get(index)+" ");
        }

    }
}