跟我一起学JAVAEE吧——JAVA_SE篇——day13上课笔记（Map集合还不会用？模拟斗地主洗牌发牌拿牌会写吗？）

day 13

Map集合

• 概述

  • 现实生活中，我们经常回看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象登，这种意一一对应的关系，叫做映射。

• Collection与Map集合的区别

  • Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储，Collection集合称为单列集合
  • Map中的集合，元素是成对存在的，每个元素由键与值两部分组成，通过键可以找对所对应的值，Map中的集合称为双列集合。

• Map集合中不能包含重复的键，值可以重复，每个键只能对应一个值

• Map常用子类

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

• Map接口中常用的方法

  • put(k key, v value)：把指定的键与指定的值添加到Map集合中

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

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

  • setkeyset()：获取Map集合中所有的键，存储到Set集合中

  • Set<Map.Entry<k,v>> entryset()：获取到Map集合中所有的键值对对象的集合（Set集合）

  • 代码演示

    public class MapTest{
        public static void main(String[]args){
            HashMap<String,String>map=new HashMap<>();
            map.put("1","杨颖");
            map.put("2","赵丽颖")；
            map.put("3","孙俪");
            System.out.println(map);
            map.remove("1");
            System.out.println(map);
            System.out.println(map.get("2"));
        }
    }
    结果：
        1=杨颖
        2=赵丽颖
        3=赵丽颖
        2=赵丽颖
        3=孙俪
        2=赵丽颖
    

• Map集合遍历方式

  • 通过键找值

    • 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键
    • 遍历键的Set集合，得到每一个键
    • 根据键，获取键所有对应的值

    public class MapDemo01{
        public static void main(String[]args){
            HashMap<String,String>map=new HashMap<>();
        	map.put("胡歌","霍建华");
        	map.put("郭德纲","于谦");
        	map.put("薛之谦","大张伟");
        	Set<String>keys=map.keyset();
        	for(String key:keys){
            String value = map.get(key);
            System.out.println(key+"的CP是："+value);
        	}
        }
    }
    

  • Entry键值对对象

    • 我们知道，Map中存放的是两种对象，一种称为Key，一种称为value，它们在Map中是一一对应关系，这一对对象又称为Map中的一个Entry项，Entry将键值对的对应关系封装成了对象。

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

      • getkey()：获取Entry对象中的键
      • getvalue()：获取Entry对象中的值
      • Set<Map.Entry<k,y>> entryset()：获取到Map集合中所有的键值对对象的集合（Set集合）

      publci class MapDemo02{
          public static void main(String[] args){
              HashMap<String,String>map = new HashMap<>();
              map.put("胡歌","霍建华");
              map.put("郭德纲","于谦");
              map.put("薛之谦","大张伟");
              Set<Entry<String,String>>entryset = map.entryset();
              for(Entry<String,String>entry:entryset){
                  String key=entry.getkey();
                  String value=entry.getValue();
                  System.out.println(key+"的CP是"+value);
              }
          }
      }
      

• HashMap存储自定义类型键值

  public class Student{
      private String name; private int age;
  	public Student() {}
  	public Student(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 boolean equals(Object o) { 
          if (this == o)
  			return true;
  		if (o == null || getClass() != o.getClass()) 
              return false;
  		Student student = (Student) o;
  		return age == student.age && Objects.equals(name, student.name);
  	}
  	@Override
  	public int hashCode() {
  		return Objects.hash(name, age);
  	}
  }
  

  测试类

  public class HashMapTest{
      public static void main(String[] args){
          Map<Student,String>Map = new HashMap<Student,String>();
          map.put(newStudent("李四",22),"北京");
          map.put(newStudent("张三",24),"上海");
          map.put(newStudent("王五",26),"重庆");
          map.put(newStudent("赵六",23),"深圳");
          map.put(newStudent("孙七",21),"成都");
          Set<Student> keyset=map.keyset();
          for(Student key:keyset){
              String value = map.get(key);
              System.out.println(key+":"+value);
          }
      }
  

• LinkedHashMap

  public class LinkedHashMapDemo{
      public static void main(String[] args){
          LinkedHashMap<String,String>map=new LinkedHashMap<>();
          map.put("邓超", "孙俪");
  		map.put("李晨", "范冰冰");
  		map.put("刘德华", "朱丽倩");
  		Set<Entry<String, String>> entrySet = map.entrySet(); 
          for (Entry<String, String> entry : entrySet) {
  			System.out.println(entry.getKey() + ":" + entry.getValue());
  		}
      }
  }
  
  结果：
      邓超：孙俪
      李晨：范冰冰
      刘德华：朱丽倩
  

模拟斗地主洗牌发牌

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

• 具体规则

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

• 案例需求分析

  • 准备牌：使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)
  • 洗牌：通过数字完成洗牌发牌
  • 发牌：将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。存放的过程中要求数字大小与斗地主规则的大小对应。将代表不同纸牌的数字分配给不同的玩家与底牌
  • 看牌：通过Map集合找到对应字符展示。通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示

• 代码

  package cn.javase.playcards2;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  
  public class CardPlay2 {
      public static void main(String[] args) {
          //花色color
          ArrayList<String> color = new ArrayList<>();
          //牌的内容
          ArrayList<String> num = new ArrayList<>();
          //牌序
          ArrayList<Integer> index = new ArrayList<>();
          //定义花色和牌的内容
          Collections.addAll(color, "♥", "♠", "♣", "♦");
          Collections.addAll(num, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
          //存储牌的内容和牌序
          HashMap<Integer, String> poker = new HashMap<>();
          //组合牌的内容和牌序
          int inde = 53;
          poker.put(inde, "大王");
          index.add(inde);
          inde--;
          poker.put(inde, "小王");
          index.add(inde);
          inde--;
          for (String s : num) {
              for (String s1 : color) {
                  poker.put(inde, s + s1);
                  index.add(inde);
                  inde--;
              }
          }
          Collections.shuffle(index);
          //定义玩家123及底牌
          ArrayList<Integer> player1 = new ArrayList<>();
          ArrayList<Integer> player2 = new ArrayList<>();
          ArrayList<Integer> player3 = new ArrayList<>();
          ArrayList<Integer> dipai = new ArrayList<>();
          //发牌
          for (int i = 0; i < index.size(); i++) {
              if (i < 51) {
                  if (i % 3 == 0) {
                      player1.add(index.get(i));
                  } else if (i % 3 == 1) {
                      player2.add(index.get(i));
                  } else if (i % 3 == 2) {
                      player3.add(index.get(i));
                  }
              } else {
                  dipai.add(index.get(i));
              }
          }
          printpoker("华仔", poker, player1);
          printpoker("星仔", poker, player2);
          printpoker("润发", poker, player3);
          printpoker("底牌", poker, dipai);
      }
  
      public static void printpoker(String name, HashMap<Integer, String> poker, ArrayList<Integer> player) {
          Collections.sort(player, new Comparator<Integer>() {
              @Override
              public int compare(Integer o1, Integer o2) {
                  return o1 - o2;
              }
          });
          System.out.println();
          System.out.print(name + ":");
          for (Integer integer : player) {
              System.out.print("|" + poker.get(integer) + "|" + "\t");
          }
          System.out.println();
      }
  }
  
  

  华仔:|3♦| |4♦| |4♠| |5♦| |7♣| |8♥| |9♦| |9♣| |9♥| |J♦| |J♣| |J♠| |Q♠| |K♠| |A♣| |2♥| |大王|

  星仔:|3♠| |3♥| |4♥| |5♣| |6♦| |6♣| |6♠| |7♦| |8♦| |9♠| |10♦| |10♣| |10♠| |J♥| |K♥| |A♠| |A♥|

  润发:|3♣| |5♠| |5♥| |6♥| |7♠| |7♥| |8♣| |8♠| |10♥| |Q♦| |Q♣| |Q♥| |K♦| |A♦| |2♦| |2♣| |2♠|

  底牌:|4♣| |K♣| |小王|