Java进阶09（Map集合、Properties属性集、可变参数、斗地主案例优化）

Part 01：Map集合

1、Map集合的特点：

• 双列集合（Collection是单列集合），元素都是成对存在的
• Map集合没有迭代器，Map不是继承Collection接口；
• Map集合元素的键是不能重复的，值可以重复；
• Collection 一个泛型，Map<K,V>两个泛型，K代表键的类型，V代表值的类型；K，V可以相同，也可以不同，必须是引用类型

2、Map集合的实现类：

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

3、Map集合的常用方法：

• V put(K key,V value);//向集合中添加键值对；如果集合中已存在该键，覆盖整个键值对，并返回被覆盖的键值对的值
• V remove( Object key);//根据键从Map集合中删除键值对，返回被删除的键值对的值
• V get(K key);//根据键从Map集合中找到唯一对应的值

4、Map集合遍历方式

• 以键找值遍历：调用keySet( )方法获取所有的键的集合；用迭代器／foreach遍历所有键的集合，在遍历的过程中获取键对应的值；

  Map<Integer,String> map = new HashMap<Integer, String>(); //添加键值对    
  map.put(1,"小丽丽");
   map.put(2,"中丽丽"); 
   map.put(3,"大丽丽"); 
   map.put(5,"高丽丽"); 
   map.put(4,"丽丽"); 
   Set keys = map.keySet();
   Iterator<Integer> it = keys.iterator(); 
   while (it.hasNext()){
    int key = it.next();
    String value = map.get(key);
    System.out.println(key+":"+value); 
    }
  

• 键值对遍历：调用entrySet( )方法获取所有键值对对象的集合；遍历这个Set集合调用getKey，getvalue方法获取键和值

  Set<Map.Entry<Integer,String>> entrys = map.entrySet();
  for ( Map.Entry entry:
    entrys) {
   int key = (int) entry.getKey();
   String value = (String) entry.getValue();
    System.out.println(key+":"+value);
  }
  

5、HashMap存储自定义类型键值：
如果Map中的键是自定义类型，那么要保证键的唯一性，必须重写键对应的自定义类的hashCode和equals方法

Part 02：Properties属性集

1、Properties类是什么？

• class Properties extends HashTable implements Map
  所以：Properties本质上就是一个Map集合
• Properties是一个持久的属性集
  所谓持久 就是它具有自己写数据到文件的方法；
• Properties没有泛型／泛型固定<String,String>

2、Properties类的方法：
具有Map接口的一切方法；
还具有以下特有的方法：
* public Object setProperty(String key,String value)//添加键值对；功能和Map中的put方法一致；
* public String getProperty(String key)//用指定的键在此属性列表中搜索属性的值；功能与Map中的get方法一致
* public Set stringPropertyNames( )//返回此属性列表中的键集；功能和Map中的keySet一致

3、Properties具有持久化到文件的功能：
store( );//保存数据到文件；
load( );//从文件中加载数据；

 Properties ps = new Properties();
 ps.setProperty("iphoneX","9888");
 ps.setProperty("xiaomiMix","3288");
 ps.setProperty("huaweiMate11","5800");
 ps.setProperty("vivoX20","2800");

 //把ps的数据持久化到文件中,第一个参数为文件名，一般后缀写成.properties，第二个参数为注释，一般不写
 ps.store(new FileWriter("phones.properties"),"");

 //从文件中读取数据
 ps.load(new FileReader("phones.properties"));
System.out.println(ps);

Part 03：可变参数

1、可变参数：

• 本质是一个数组；
• 说的不是参数类型可变，而是参数的个数可以变化；

2、语法：

public 返回值类型 方法名（数据类型…参数名）{ }

注意⚠️：

• 可变参数只是参数的个数是任意个的，参数的类型不能改变

• 一个方法中，最多只能有一个可变参数

• 当一个方法中有多个参数，并且有一个参数是可变参数时，这个可变参数必须放最后；

  public  int add(int b,int...a){
     int sum = 0;
    for (int x:
     a) {
    sum=sum+x;
   }
  return sum+b;
  }
  

Part 04：斗地主案例优化

• 手中的牌按从小到大的顺序排列

  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.LinkedHashMap;
  import java.util.Map;
  
  public class Doudizhu {
    public static void main(String[] args){
        //1.创建编号和牌对应的map集合,编号越大牌越大
        Map<Integer,String> map = new LinkedHashMap<Integer,String>();
        //2.创建牌的编号对应的ArrayList集合
        ArrayList<Integer> arraylist = new ArrayList<Integer>();
        //3.向Map,ArrayList中添加数据
          //编号
        int id = 1;
          //花色和数值
        String[] colors={"♠️","♥️","♣️","♦️"};
        String[] numbers={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
          //生成牌
        for (String num:numbers
             ) {
            for (String color:colors
                 ) {
                String card = color+num;
                map.put(id,card);
                arraylist.add(id);
                id++;
            }
        }
        map.put(id,"小王");
        arraylist.add(id);
        id++;
        map.put(id,"大王");
        arraylist.add(id);
    //4.洗牌
    Collections.shuffle(arraylist);
  
  
    //5.发牌
    ArrayList<Integer> person1Id = new ArrayList<Integer>();
    ArrayList<Integer> person2Id = new ArrayList<Integer>();
    ArrayList<Integer> person3Id = new ArrayList<Integer>();
    ArrayList<String> remaining = new ArrayList<String>();
     //给三个玩家轮流发牌
    for (int i=0;i<arraylist.size()-3;i++){
        person1Id.add(arraylist.get(i));
        i++;
        person2Id.add(arraylist.get(i));
        i++;
        person3Id.add(arraylist.get(i));
    }
    //剩下的三张底牌
    for (int j=arraylist.size()-3;j<arraylist.size();j++){
        //获取牌的编号
        int remainningId = arraylist.get(j);
        //根据牌的编号找到牌
        String remainingCard = map.get(remainningId);
        //将牌添加到ArrayList中
        remaining.add(remainingCard);
    }
    System.out.println("底牌："+remaining);
  
    //6.给三个玩家手里的牌排序
    Collections.sort(person1Id);
    Collections.sort(person2Id);
    Collections.sort(person3Id);
  
  
    ArrayList<String> person1Card = new ArrayList<String>();
    ArrayList<String> person2Card = new ArrayList<String>();
    ArrayList<String> person3Card = new ArrayList<String>();
    //7.看牌
    //根据牌的编号从Map集合中获取他的牌
    for (int i:person1Id
         ) {
        String value = map.get(i);
        person1Card.add(value);
    }
    for (int i:person2Id
            ) {
        String value = map.get(i);
        person2Card.add(value);
    }
    for (int i:person3Id
            ) {
        String value = map.get(i);
        person3Card.add(value);
    }
    System.out.println(person1Card);
    System.out.println(person2Card);
    System.out.println(person3Card);
   }
  }
  

结果为：