Java：Map，Collections工具类，斗地主

Map:

Map:

1、Map：双列集合的顶层接口
2、Map：单词含义，地图，地图上的每个点，都表示了生活中的一个具体位置。地图的点和生活中的位置，有一个一一对应的关系，这种关系是通过穷举的方式来描述的。
3、Map：描述的就是一个数据（key）到另一个数据（value）的映射关系（对应关系）
一个数据（key）：就是有规律的，容易记忆的，简单的一个数据
另一个数据（value）：没有规律的，不容易记忆的，复杂的一个数据
大多数都是根据key来寻找value
4、映射：对应关系
{key1=value1,key2=value2,key3=value3,key4=value4…}
穷举罗列：{1=1, 2=4, 3=9, 4=16, 5=25}
5、java中Map就是使用的穷举罗列的方式来描述映射关系
6、Map的特点：
Key（键）是唯一的，value（值）不是唯一的
每个键都只能对应确定唯一的值
7、Map和Collection的区别：
Map是双列集合，Collection是单列集合
Map的键是唯一的，Collection中的Set子接口中的元素是唯一的
Map的所有操作和算法都是针对键有效，Collection中的set子接口中的操作和算法针对元素有效

Map中的常用方法

1、增加键值对：put(K key, V value)
2、删除方法：
根据给定的键，删除对应的键值对：remove(K key)
清空集合：clear()
3、获取方法：
获取集合的大小：size()，获取键值对对数
根据给定的键，获取对应的值：V get(K key)
4、判断方法：
判断集合中是否存在某个键：containsKey(Object obj)
判断集合中是否存在某个值：containsValue(Object obj)
5、修改方法：
根据给定的键，修改对应的值：put(K key, V value)
如果在集合中已经存在key这个键，那么使用put方法，就是修改其对应的值；如果集合中不存在key这个键，那么使用put方法，就是在集合中增加了一个键值对

Map集合遍历思路

需求：键盘录入一个字符串，统计每个字符出现的次数
例如，录入aaaabbccddd!@#@#KaTeX parse error: Expected 'EOF', got '#' at position 2: @#̲%cc66ff
打印出来：a有4个，b有2个，c有4个，d有3个，!有1个，@有3个，$有2个，%有1个，6有2个，f有2个

HashMap

LinkedHashMap

1、是HashMap的一个子类，数组加上双重链表进行存储，有序
2、和HashMap的不同之处在于，具有可预知的迭代顺序，存储键值对的顺序和遍历集合时取出键值对的顺序一致。

HashMap和Hashtable的关系

1、HashMap和Hashtable都是用于存储键和值的对应关系，都是Map的实现类，都是使用哈希表的方式存储。
2、不同点：
1、版本不同，Hashtable是jdk1.0版本出现的，HashMap是jdk1.2版本出现的
2、线程安全性不同，Hashtable是线程安全的，HashMap是线程不安全的
3、Hashtable不能存储null键null值，HashMap可以存储null键null值
4、命名规则：Hashtable时期没有形成完全严格的命名要求

Collections工具类:

斗地主：

public class Test1 {
/**
* 斗地主：1.有牌 （54） 四种花色（红桃，方块，黑桃，梅花）（A—K）大小王
* //生成54 张牌
*

* 2.洗牌
* 3.发牌 3 * 17 + 底牌 3 = 54
* 4.看牌
*/
public static void main(String[] args) {
//写一个集合保存生成的扑克牌
ArrayList picket = new ArrayList<>();

    //定义两个数组，一个数组表示花色
    String[] huase = {"方块", "梅花", "红桃", "黑桃"};
    //定义一个数组表示
    String[] nums = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    for (int i = 0; i < huase.length; i++) {
        //循环数字
        for (int j = 0; j < nums.length; j++) {
            picket.add(huase[i] + nums[j]);
        }
    }
    picket.add("小王");
    picket.add("大王");

// System.out.println(list);
//洗牌
Collections.shuffle(picket);
// System.out.println(list);

    //选手1
    ArrayList<String> gaojin = new ArrayList<>();
    //选手2
    ArrayList<String> liudehua = new ArrayList<>();
    //选手3
    ArrayList<String> me = new ArrayList<>();
    //底牌的集合
    ArrayList<String> dipai = new ArrayList<>();

    //发牌
    for (int i = 0; i <picket.size() ; i++) {
        //把底牌拿出来
        if(i>=picket.size()-3){
            dipai.add(picket.get(i));
        }else if(i % 3==0){
            liudehua.add(picket.get(i));
        }else if(i % 3==1){
            gaojin.add(picket.get(i));
        }else if(i % 3==2){
            me.add(picket.get(i));
        }
    }

    System.out.println("gaojin:\t"+gaojin);
    System.out.println("liudehua:\t"+liudehua);
    System.out.println("me:\t"+me);
    System.out.println("dipai:\t"+dipai);
}

}

public class Test2 {
/**
* 斗地主：1.有牌 （54） 四种花色（红桃，方块，黑桃，梅花）（A—K）大小王
* //生成54 张牌
*

* 2.洗牌
* 3.发牌 3 * 17 + 底牌 3 = 54
* 4.看牌
*/

public static void main(String[] args) {
    //把索引放入一个集合，只能洗集合
    ArrayList<Integer> list = new ArrayList<>();

    HashMap<Integer,String> map = new HashMap<>();

    //定义两个数组，一个数组表示花色
    String[] huase = {"方块", "梅花", "红桃", "黑桃"};
    //定义一个数组表示
    String[] nums = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
    int index = 0;
    for (int i = 0; i <nums.length ; i++) {
        for (int j = 0; j <huase.length ; j++) {
            map.put(index,huase[j]+ nums[j]);
            list.add(index);
            index++;
        }
    }
    System.out.println(index);
    list.add(index);
    map.put(index,"小王");
    index++;
    map.put(index,"大王");
    list.add(index);
    System.out.println(list);

    //洗牌    TreeSet(自动排序的功能)
    Collections.shuffle(list);

// System.out.println(list);

    //选手1
    TreeSet<Integer> gaojin = new TreeSet<>();
    //选手2
    TreeSet<Integer> liudehua = new TreeSet<>();
    //选手3
    TreeSet<Integer> me = new TreeSet<>();
    //底牌的集合
    TreeSet<Integer> dipai = new TreeSet<>();

    //发牌
    for (int i = 0; i <list.size() ; i++) {
        //把底牌拿出来
        if(i>=list.size()-3){
            dipai.add(list.get(i));
        }else if(i % 3==0){
            liudehua.add(list.get(i));
        }else if(i % 3==1){
            gaojin.add(list.get(i));
        }else if(i % 3==2){
            me.add(list.get(i));
        }
    }

/* System.out.println(“gaojin:\t”+gaojin);
System.out.println(“liudehua:\t”+liudehua);
System.out.println(“me:\t”+me);
System.out.println(“dipai:\t”+dipai);*/

    //看牌
    lookPicket("高进",gaojin,map);
    lookPicket("刘德华",liudehua,map);
    lookPicket("我",me,map);
    lookPicket("底牌",dipai,map);
}


//看牌：名字   选手当前牌的索引   map

public static void lookPicket(String name,TreeSet<Integer> treeSet,
                              HashMap<Integer,String> map){
    System.out.println(name+":");
        Iterator<Integer> iter = treeSet.iterator();
        while(iter.hasNext()){
            System.out.print(map.get(iter.next())+" ");
    }
    System.out.println("");   //选手换行
}

}