java中的Map集合，debug操作，Map集合斗地主案例分析

Map集合

概述

现实生活中，我们常会看到这样的一种集合:IP地址与主机名身份证号与个人，系统用户名与系统用户对象等这种–对应的关系，就叫做映射。java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。

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

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

Map常用子类

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集

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

tips:Map接口中的集合都有两个泛型变量在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

Map接口中的常用方法

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

• public V put(K key,V value):把指定的键与指定的值添加到Map集合中。

• public V remove(Object key):把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。

• public V get(Object key):根据指定的键，在Map集合中获取对应的值。

• boolean containskey(Object key):判断集合中是否包含指定的键。

  package com.company.pratise;
  
  import java.util.HashMap;
  import java.util.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之后：数组+单向链表/红黑树(链表的长度超过8)：提高查询的速度
          2.HashMap集合是一个无序的集合存储元素和取出元素的顺序有可能不一致
      java.util.LinkedHashMap<K,V>集合 extends HashMap<K,V>集合
      LinkedHashMap的特点：
          1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
          2.LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的
   */
  public class Demo01Map {
      public static void main(String[] args) {
          show04();
      }
  
      /*
          public V put(K key,V value):把指定的键与指定的值添加到Map集合中
              返回值：V
                  存储键值对的时候，key不重复，返回V是null
                  存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的value
       */
      private static void show01(){
          //创建Mao集合对象，多态
          Map<String,String> map = new HashMap<>();
  
          String v1 = map.put("李晨","范冰冰1");
          System.out.println("v1:" + v1);//v1:null
  
          String v2 = map.put("李晨","范冰冰2");
          System.out.println("v2:" + v2);//v2:范冰冰1
  
          System.out.println(map);//{李晨=范冰冰2}
  
          map.put("冷锋","龙小云");
          map.put("杨过","小龙女");
          map.put("伊志平","龙小云");
          System.out.println(map);//{杨过=小龙女, 伊志平=龙小云, 李晨=范冰冰2, 冷锋=龙小云}
      }
  
      /*
          public V remove(Object key)`把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值
              返回值：V
                  key存在，V返回被删除的值
                  key不存在，V返回null
       */
      private static void show02() {
          //创建Mao集合对象
          Map<String, Integer> map = new HashMap<>();
          map.put("赵丽颖",168);
          map.put("杨颖",165);
          map.put("林志玲",178);
          System.out.println(map);//{林志玲=178, 赵丽颖=168, 杨颖=165}
  
          Integer v1 = map.remove("林志玲");
          System.out.println("v1:" + v1);//v1:178
          System.out.println(map);//{赵丽颖=168, 杨颖=165}
  
          //int v2 = map.remove("林志颖");//自动拆箱 NullPointerExcetion
          Integer v2 = map.remove("林志颖");
          System.out.println("v2:" + v2);//v2:null
          System.out.println(map);
      }
  
      /*
          public V get(Object key):根据指定的键，在Map集合中获取对应的值
              返回值：V
                  key存在，返回对应的value值
                  key不存在，返回null
       */
      private static void show03() {
          //创建Mao集合对象
          Map<String, Integer> map = new HashMap<>();
          map.put("赵丽颖",168);
          map.put("杨颖",165);
          map.put("林志玲",178);
  
          Integer v1 = map.get("杨颖");
          System.out.println("v1:" + v1);//v1:165
  
          Integer v2 = map.get("迪丽热巴");
          System.out.println("v2:" + v2);//null
      }
  
      /*
          boolean containskey(Object key):判断集合中是否包含指定的键
              包含返回true，不包含返回false
       */
      private static void show04() {
          //创建Mao集合对象
          Map<String, Integer> map = new HashMap<>();
          map.put("赵丽颖",168);
          map.put("杨颖",165);
          map.put("林志玲",178);
  
          boolean v1 = map.containsKey("杨颖");
          System.out.println("v1:" + v1);//v1:true
  
          boolean v2 = map.containsKey("迪丽热巴");
          System.out.println("v2:" + v2);//false
      }
  }
  

• public Set<k> keySet():获取Map集合中所有的键，存储到Set集合中（应用Map集合遍历键找值方式）

• public Set<Map.Entry<K,V>>entrySet():获取到Map集合中所有的键值对对象的集合(Set集合)。（应用Entry键值对对象、Map集合遍历键值对方式）

Map集合遍历键找值方式

键找值方式:即通过元素中的键，获取键所对应的值
分析步骤

1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法提示: get(K key)

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

/*
    Map集合的第一种遍历方法：通过键找值的方法
    Map集合中的方法：
        Set<K> keySet() 返回映射中包含的键的Set 视图
    实现步骤：
        1.使用Map集合中的方法keySet(),把Mao集合所有的key取出来，存储到一个Set集合中
        2.遍历set集合，获取Map集合中的每一个key
        3.通过Map结合中的方法get(key)，通过key找到value
*/
public class Demo02Map_KeySet {
    public static void main(String[] args) {
        //创建Mao集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("林志玲",178);

        //1.使用Map集合中的方法keySet(),把Mao集合所有的key取出来
        Set<String> set = map.keySet();

        //2.遍历set集合，获取Map集合中的每一个key
        //使用费迭代器遍历Set集合
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String key = it.next();
            //3.通过Map结合中的方法get(key)，通过key找到value
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("=================");
        for(String key : map.keySet()){
            //3.通过Map集合中的方法get(key)，通过key找到value
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }
    }
}

Entry键值对对象

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

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法

• public K getkey():获取Entry对象中的键。
• public V getvalue():获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法

• public Set<Map.Entry<K,V>> entrySet():获取到Map集合中所有的键值对对象的集合(Set集合)。

Map集合遍历键值对方式

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

/*
    Map集合遍历的第二种方法：使用Entry对象遍历
    Map集合中的方法：
        Set<Map.Entry<K,V>> entrySet() 返回次映射中包含的映射关系的Set视图
    实现步骤：
        1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中
        2.遍历Set集合，获取每一个Entry对象
        3.使用Entry对象中的方法getKey()和getValue()获取键与值
 */
public class Demo03Map_EntrySet {
    public static void main(String[] args) {
        //创建Mao集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("林志玲",178);

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

        //2.遍历Set集合，获取每一个Entry对象
        //使用迭代器遍历Set集合
        Iterator<Map.Entry<String,Integer>> it = set.iterator();
        while (it.hasNext()){
            Map.Entry<String,Integer> entry = it.next();
            //3.使用Entry对象中的方法getKey()和getValue()获取键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        System.out.println("====================");
        //使用增强for循环遍历Set集合
        for(Map.Entry<String,Integer> entry : set){
            //3.使用Entry对象中的方法getKey()和getValue()获取键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}

LinkedHashMap

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

/*
    java.util.LinkedHashMap<K,V> entends HashMap<K,V>
    Map接口的哈希表和连接列表实现，具有可预知的迭代顺序
    底层原理：
        哈希表+链表结构（记录元素的顺序）
 */
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("a","d");
        System.out.println(map);//{a=d, b=b, c=c}  key不允许重复，无序

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

Hashtable（了解）

import java.util.HashMap;
import java.util.Hashtable;

/*
    java.util.Hashtable<K,V>集合 implements Map<K,V>接口

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

    HashMap集合（之前学的所有的集合）：可以存储null值，null键
    Hashtable集合，不能存储null值，null键

    Hashtable和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap，ArrayList）
    Hashtable的子类Properties依然活跃在历史舞台
    properties集合是一个唯一和IO流相结合的集合

*/
public class Demo05Map_Hashtable {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put(null,"a");
        map.put("b",null);
        map.put(null,null);
        System.out.println(map);//{null=null, b=null}

        Hashtable<String,String> table = new Hashtable<>();
        //table.put(null,"a");//NullPointerException
        //table.put("b",null);//NullPointerException
        //table.put(null,null;//NullPointerException
    }
}

Map 集合练习

分析

代码

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

/*
    练习：
        计算一个字符串中每个字符出现次数
    分析：
        1.使用Scanner获取用户输入道德字符串
        2.使用Map集合，key是字符串中的字符，value是字符的个数
        3.遍历字符串，获取每一个字符
        4.使用获取的字符，去Map集合判断key是否存在
            key存在：
                通过字符key，获得value（字符个数）
                value++
                put(key,value)把新的value存储到Map集合中
            key不存在：
                out(key,1)
        5.遍历Map集合，输出结果
 */
public class Demo06MapTest {
    public static void main(String[] args) {
        //1.使用Scanner获取用户输入道德字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        //2.使用Map集合，key是字符串中的字符，value是字符的个数
        HashMap<Character,Integer> map = new HashMap<>();
        //3.遍历字符串，获取每一个字符
        for(char c : str.toCharArray()){
            //4.使用获取的字符，去Map集合判断key是否存在
            if(map.containsKey(c)){
                //key存在
                Integer value = map.get(c);
                value++;
                map.put(c,value);
            }else{
                //key不存在
                map.put(c,1);
            }
        }
        //5.遍历Map集合，输出结果
        for(Character key : map.keySet()){
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }
    }
}

补充知识点

JDK9对集合添加的优化

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

/*
    JDK9的新特性：
        List接口，Set接口，Map接口：里边增加了一个静态的方法of，可以给集合一次性添加多个元素
        static <E> List<E> of (E...elements)
        使用前提：
            当集合中存储的元素的个数已经确定了，不再改变时使用
        注意：
            1.of方法值使用于List接口，Set接口，Map接口：不适用于接口的实现类
            2.of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法添加元素，会抛出异常
            3.Set接口和Map接口在调用of方法的时候，不能有重复的元素，否则会抛出异常
 */
public class Demo01JDK9 {
    public static void main(String[] args) {
        List<String> list = List.of("a","b","a","c","d");
        System.out.println(list);//[a,b,a,c,d]
        //list.add("w");//UnsupportedOperationException:不支持异常

        //Set<String> set = Set.of("a","b","a","c","d");//IllegalArgumentException:非法参数异常，有重复的元素
        Set<String> set = Set.of("a","b","c","d");
        System.out.println(set);//[d,c,b,a]
        //set.add("w");//UnsupportedOperationException:不支持异常

        //Map<String,Integer> map = Map.of("张三",18,"李四",19,"王五",20,"张三",19);//IllegalArgumentException:非法参数异常，有重复的元素
        Map<String,Integer> map = Map.of("张三",18,"李四",19,"王五",20);
        System.out.println(map);//{王五=20, 李四=19, 张三=18}
        //map.put("老六",30);//UnsupportedOperationException:不支持异常
    }
}

Debug追踪

• Debug调试程序：
  可以让代码逐行执行，查看代码执行的过程，调试程序中出现的bug
• 使用方法：
  在行号的右边，鼠标左键单击，添加断点（每个方法的第一行，哪里有bug添加到哪里）
  右键选择Debug执行程序
  程序就会停留在添加的第一个断点处
• 执行程序：
  f8：逐行执行程序
  f7：进入到方法中
  shift+f8：跳出方法
  f9：跳到下一个断点，如果没有下一个断点，那么就结束程序
  Ctrl+f2：退出debug模式，停止程序
  Console：切换到控制台

模拟斗地主洗牌发牌

案例介绍

按照斗地主的规则，完成洗牌发牌的动作

​ 令狐冲:[♠2，♦A，♥A，♠A，♣K，♥Q，♦J，♥J，♦9，♣7，♦5，♥4，♠4，♣3，♥3，♠3]
​ 石破天: [小王，♦2，♣2，♥2，♣A，♦K，♣Q，♦10，♥10，♠10，♠8，♣6，♥6，♣5，♠5，♦4，♣4]
​ 鸠摩智:[大王，♥K，♦Q，♠Q，♣10，♥9，♠9，♣8，♦7，♥7，♠7，♦6，♠6，♥5，♦3]
​ 底牌:[♠K，♠J，♣9]

具体规则:

1. 组装54张扑克牌将
2. 54张牌顺序打乱
3. 三个玩家参与游戏三人交替摸牌，每人17张牌，最后三张留作底牌
4. 查看三人各自手中的牌(按照牌的大小排序)、底牌

规则:手中扑克牌从大到小的摆放顺序:大王,小王2,A,K,Q,10,9,87,6,5,4,3

案例分析

代码实现

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

/*
    斗地主综合案例：有序版本
		1.准备牌
		2.洗牌
		3.发牌
		4.排序
		5.看牌
 */
public class Doudizhu2 {
    public static void main(String[] args) {
        //1.准备牌
        //创建一个Map集合，存储牌的索引和组装好的牌
        HashMap<Integer,String> poker = new HashMap<>();
        ArrayList<Integer> pokerIndex = new ArrayList<>();
        //定义两个集合，存储花色和牌的序号
//        List<String> colors = List.of("♠","♥","♣","♦");
//        List<String> numbers = List.of("2","A" ,"K","Q","J","10","9","8","7","6","5","4","3");
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"2","A" ,"K","Q","J","10","9","8","7","6","5","4","3"};
        //把大王小王存储到集合中
        //定义一个牌的索引
        int index = 0;
        poker.put(index,"大王");
        pokerIndex.add(index);
        index++;
        poker.put(index,"小王");
        pokerIndex.add(index);
        index++;
        //循环嵌套遍历两个集合，组装52张牌，存储到集合中
        for (String number : numbers) {
            for (String color : colors) {
                poker.put(index,color+number);
                pokerIndex.add(index);
                index++;
            }
        }
//        System.out.println(poker);
//        System.out.println(pokerIndex);
        /*
            2.洗牌
            使用Collections中的方法shuffle(List)
         */
        Collections.shuffle(pokerIndex);
        //System.out.println(pokerIndex);

        //3.发牌
        //定义4个集合，存储玩家的牌和底牌
        ArrayList<Integer> player01 = new ArrayList<>();
        ArrayList<Integer> player02 = new ArrayList<>();
        ArrayList<Integer> player03 = new ArrayList<>();
        ArrayList<Integer> diPai = new ArrayList<>();

        /*
        	遍历pokerIndex集合，获取每一张牌
        	使用pokerIndex集合的索引%3给3个玩家轮流发牌
        	剩余3张牌给底牌
        	注意：
        		先判断底牌(i>=51),否则牌就发没了
        */
        for(int i = 0; i < poker.size(); i++){
            //获取每一张牌
            Integer in = pokerIndex.get(i);
            //轮流发牌
            if(i >= 51){
                //改底牌发牌
                diPai.add(in);
            }else if(i % 3 == 0){
                //给玩家1发牌
                player01.add(in);
            }else if(i % 3 == 1){
                //给玩家2发牌
                player02.add(in);
            }else if(i % 3 == 2){
                //给玩家3发牌
                player03.add(in);
            }
        }

        /*
            4.排序
            使用Collections中的方法sort(List）
            默认是升序排序
         */
        Collections.sort(player01);
        Collections.sort(player02);
        Collections.sort(player03);
        Collections.sort(diPai);

        /*
            5.看牌
            调用看牌的方法
         */
        lookpoker("令狐冲",poker,player01);
        lookpoker("石破天",poker,player02);
        lookpoker("鸠摩智",poker,player03);
        lookpoker("底牌",poker,diPai);
    }
    /*
        定义一个看牌的方法，提高代码的复用性
        参数：
            String name:玩家名称
            HashMap<Integer,String> poker : 存储牌的集合
            ArrayList<Integer> list ：存储玩家和底牌的list集合
        查表发：
            遍历玩家或者底牌集合，获取牌的索引
            使用牌的索引，去Map集合中，找到对应的牌
     */
    public static void lookpoker(String name,HashMap<Integer,String> poker,ArrayList<Integer> list){
        //输出玩家名称，不换行
        System.out.print(name + ":");
        //遍历玩家或底牌集合，获取牌的索引
        for (Integer key : list) {
            //使用牌的索引，去Map集合中，找到对应的牌
            String value = poker.get(key);
            System.out.print(value + " ");
        }
        System.out.println();//打印完每一个玩家的牌，换行
    }
}