集合最后的实验总结

简易的模拟斗地主的小程序

一.要求：

1.该程序包括了斗地主中的洗牌，发牌，以及看牌等相关操作

2.要将牌的大小进行排序

3.同时看三个人的手牌，以及底牌

二.分析程序：

1.首先我们需要创建一个ArrayList集合来当牌盒，通过Collections的工具类中的Shufferle来打乱牌

2.发牌可以创建三个集合来存储各自的牌，最后通过遍历的方式来实现看牌的操作

3.因为要将牌的大小排序，所以使用TreeSet来作为集合存储，而扑克牌中含有大小王，A,J,Q,K，以及花色组成，所以牌是String类型的数组，不好比较，所以使用HashMap<Integer，String>,来创建相关索引，用Integer来比较牌的大小，最后调用这个HashMap集合来查看自己的手牌

4.因为要查看各自手牌，所以创建一个方法来调用，减少代码量。

三.具体步骤:

1.创建一个ArrayList来存放Integer，并使用Collections.shuffle;来对其进行打乱

2.创建一个HashMap集合来存放扑克牌，创建相关索引

3.创建三个TreeSet集合来存储Key值，并排序

4.创建看牌的静态方法，通过Key值来得到每个人具体的牌

四.具体实现：

package Test.Map;

import java.util.*;

public class Pock {
    public static void main(String[] args){
        HashMap<Integer,String> hashMap = new HashMap<>();
        //创建一个HashMap集合来存放扑克牌，创建相关索引
        ArrayList<Integer> num = new ArrayList<>();
        //创建一个ArrayList来存放Integer
        TreeSet<Integer> player1 = new TreeSet<>();
        TreeSet<Integer> player2 = new TreeSet<>();
        TreeSet<Integer> player3 = new TreeSet<>();
        //创建三个TreeSet集合来存储Key值，并排序
        TreeSet<Integer> dipai = new TreeSet<>();
        //这个用来存放底牌
        String[] color = {"♣","♥","♦","♠"};
        String[] number = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        int i = 0;
        for (String n:number){
            for(String c:color){
                i++;
                hashMap.put(i,c+n);
                num.add(i);
                //通过增强For循环来遍历String[] ，并将得到的值放进HashMap中
            }
        }
        hashMap.put(i++,"小王");
        num.add(i);
        hashMap.put(i++,"大王");
        num.add(i);
        //还有大小双王
        Collections.shuffle(num);
        //打乱牌
        for (int j = 1;j<num.size();j++){
            if (j>=num.size()-3){
                dipai.add(num.get(j));
                //保留三张底牌
            }else {
                if (j%3==0){
                    player1.add(j);
                    //通过取余的方式，来逐一发牌
                }else if (j%3==1){
                    player2.add(j);
                }else if (j%3==2){
                    player3.add(j);
                }
            }

        }
        System.out.println("玩家一：");
        See(player1,hashMap);
        System.out.println("底牌：");
        See(dipai,hashMap);

    }
    public static void See(TreeSet<Integer> player,HashMap<Integer,String> hashMap){
        //看牌方法
        for (Integer i:player){
            //使用增强For循环来遍历玩家手中的牌，通过索引查看具体；
            System.out.print(hashMap.get(i)+" ");
        }
    }
}
//以下是初始版，逐一修改成型。
/*
{
        ArrayList<String> list = new ArrayList<>();
        ArrayList<String> play1 = new ArrayList<>();
        ArrayList<String> play2 = new ArrayList<>();
        ArrayList<String> play3 = new ArrayList<>();
        String[] color = {"♣","♥","♦","♠"};
        String[] number = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        for (String color1:color){
            for (String number1:number){
                list.add(color1+number1);
            }
        }
        list.add("FJoker");
        list.add("RJoker");
        Collections.shuffle(list);
        for (int i = 0;i<list.size();i++){
            if (i%3==0){
                play1.add(list.get(i));
            }else if (i%3==1){
                play2.add(list.get(i));
            }else if (i%3==2){
                play3.add(list.get(i));
            }
        }
        for (String s:play1){
            System.out.println("Player1:"+s);
        }
        for (String s:play2){
            System.out.println("Player2:"+s);
        }
        for (String s:play3){
            System.out.println("Player3:"+s);
        }
    }
 */
/*
{
        int i = 0;
        HashMap<Integer,String> hashMap = new HashMap<>();
        ArrayList<String> pocker = new ArrayList<>();
        ArrayList<Integer> num = new ArrayList<>();
        String[] color = {"♣","♥","♦","♠"};
        String[] number = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        for (String number1:number){
            for (String color1:color){
                pocker.add(color1+number1);
            }
        }
        pocker.add("FJoker");
        pocker.add("RJoker");
        for (String s:pocker){
            hashMap.put(i,s);
            i++;
        }
        for (int j = 0;j<i;j++){
            num.add(j);
        }
        Collections.shuffle(num);
        TreeMap<Integer,String> player1 = new TreeMap<>();
        TreeMap<Integer,String> player2 = new TreeMap<>();
        TreeMap<Integer,String> player3 = new TreeMap<>();
        for (Integer n: num){
            if (n%3==0){
            player1.put(n,hashMap.get(n));
            }else if (n%3==1){
                player2.put(n,hashMap.get(n));
            }else if (n%3==2){
                player3.put(n,hashMap.get(n));
            }
        }
        Set<Map.Entry<Integer, String>> entries = player1.entrySet();
        for ( Map.Entry<Integer, String> set:entries){
            System.out.print(set.getValue()+" ");
        }

    }
 */

五.总结

集合可以包含多个数据类型，用于遍历，存储等，而此处的数据类型可有很多种，不一一列举了；

最后总结下，常用的一些数据类型的特点：

ArrayList<>，具有顺序性，即先进先出，具备可重复性，输入的元素可以有重复；

List<>,同上

Set<>，不具备顺序性，但是具备不可重复性，不可输入重复的元素

HashSet<>,同上

LinkerHashSet<>，具有顺序性，即先进先出，具备不可重复性，不可输入重复的元素

TreeSet<>,具有不可重复性，且内置Comparator方法，可进行自然排序，若TreeSet中的元素无法自然排序时，要使用匿名内部类，重写比较方法。

Map<K,V>,用于存放一些相关的索引，Key不可重复，具有顺序性

HashMap<>同上。