集合之斗地主案例

标签：map String 斗地主 int ArrayList System 案例集合 new

 1 package com.Lucky.AppUnit;
 2 
 3 /**
 4  * 开启App入口
 5  */
 6 public class App {
 7     public static void main(String[] args) {
 8        // new startGame();
 9 //        new InnerGame();
10 //        new overGame();
11         new valuesGame();
12     }
13 }

package com.Lucky.AppUnit;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
/*
初级版
 */
public class startGame {
        //1.准备一副扑克牌
       static ArrayList<String> house=new ArrayList<>();  //扑克牌盒子

       //利用代码块加载:与类一起加载，只加载一次
    static{
        //定义花色
           String[] huase={"♠","♥","♦","♣"};
       //定义牌面数字
           String[] num={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};


           //方法一：用for循环遍历添加不同花色的扑克牌
           for (int i = 0; i < huase.length; i++) {
               //遍历添加同一花色的扑克牌
               for (int j = 0; j < num.length; j++) {
                   house.add(huase[i]+num[j]);
               }
           }

         //方法二：用增强for循环添加数据
//           for (String s : huase) {
//               for (String n : num) {
//                   house.add(s+n);
//               }
//           }

           //还有大王和小王
           house.add("大王");
           house.add("小王");
       }


    public startGame() {
       /// System.out.println(house);
        //2.  洗牌
        Collections.shuffle(house);
      //  System.out.println(house);
        //3.发牌
         ArrayList<String> lord=new ArrayList<>();  //底牌
         ArrayList<String> player1=new ArrayList<>();
         ArrayList<String> player2=new ArrayList<>();
         ArrayList<String> player3=new ArrayList<>();


        for (int i = 0; i < house.size(); i++) {
           String val= house.get(i);
            if(i<3){ //前三张牌作为底牌
                lord.add(val);
                continue;  //跳出本次循环，进入下次循环
            }

            //底牌完成之后，轮流发牌
            if(i%3==0){  //发牌给第一个人
                player1.add(val);
            }else if(i%3==1){  //发牌给第二个人
                player2.add(val);
            }else if(i%3==2){//发牌给第三个人
                player3.add(val);
            }
        }

        //看牌
        lookPoker("底牌",lord);
        lookPoker("唯易",player1);
        lookPoker("大帅哥",player2);
        lookPoker("SB",player3);

    }

    public void lookPoker(String name,ArrayList<String> lists){
        lists.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println();
        System.out.print(name+"的牌=");
        for (String list : lists) {
            System.out.print(list+"\t");
        }
    }
}

package com.Lucky.AppUnit;
import java.util.*;

/*
中级版 ：利用指定序号排序
 */
public class InnerGame {
        //1.准备一副扑克牌
       static HashMap<Integer,String> map=new HashMap<>();   //牌盒
       static ArrayList<Integer> ArrList=new ArrayList<>();  //装序号的盒子

       //利用代码块加载:与类一起加载，只加载一次
    static{
        //定义花色
           String[] huase={"♠","♥","♦","♣"};
       //定义牌面数字
           String[] num={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};


          int index=1;   //牌的序号
           //遍历添加牌
           for (String s : num) {
               //遍历添加牌的数字
               for (String n : huase) {
                   //添加牌的花色
                   map.put(index,n+s);  //序号以及牌
                   index++;
               }
           }

           //还有大王 /小王
           map.put(index,"小王");
           index++;
           map.put(index,"大王");

       }


    public InnerGame() {
//        System.out.println(map);
        //1.将牌盒序号加入 ArrList 集合
        Set<Integer> integers = map.keySet();
        for (Integer in : integers) {
            ArrList.add(in);
        }

        //2.打乱顺序【洗牌】
        Collections.shuffle(ArrList);


        //发牌跟准备各自的牌集合
        ArrayList<Integer> lord=new ArrayList<>();
        ArrayList<Integer> palyer1=new ArrayList<>();
        ArrayList<Integer> palyer2=new ArrayList<>();
        ArrayList<Integer> palyer3=new ArrayList<>();



        for (int i = 0; i < ArrList.size(); i++) {
           int num= ArrList.get(i);
            if(i<3){  //底牌
                lord.add(num);
                continue;
            }

            //轮流发牌给三个人
            if(i%3==0){
                palyer1.add(num);
            }else if(i%3==1){
                palyer2.add(num);
            }else if(i%3==2){
                palyer3.add(num);
            }
        }

        //看牌
        lookPoker("地主",lord);  //底牌
        lookPoker("唯易",palyer1);  //玩家1
        lookPoker("大帅哥",palyer2);  //玩家2
        lookPoker("大SB",palyer3);  //玩家3
    }

    public void lookPoker(String name,ArrayList<Integer> lists){
        //再将lists集合中的数字排序
        lists.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        //将序号的数据经过map遍历获取到值，添加到集合中
        ArrayList<String> New=new ArrayList<>();


        System.out.println();
        System.out.print(name+"的牌=");
        //根据键遍历map集合来获取相对应的值
        Set<Map.Entry<Integer, String>> entries = map.entrySet();

        for (Integer list : lists) {
            for (Map.Entry<Integer, String> entry : entries) {
                Integer key = entry.getKey();
                String value = entry.getValue();
                if(key==list){
                    New.add(value);
                }
            }
        }

        for (String s : New) {
            System.out.print(s+"\t");
        }
    }
}

package com.Lucky.AppUnit;
import java.util.*;

/*
中级版 ：利用指定序号排序【简化写法】
 */
public class overGame {
        //1.准备一副扑克牌
       static HashMap<Integer,String> map=new HashMap<>();   //牌盒
       static ArrayList<Integer> ArrList=new ArrayList<>();  //装序号的盒子

       //利用代码块加载:与类一起加载，只加载一次
    static{
        //定义花色
           String[] huase={"♠","♥","♦","♣"};
       //定义牌面数字
           String[] num={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};


          int index=1;   //牌的序号
           //遍历添加牌
           for (String s : num) {
               //遍历添加牌的数字
               for (String n : huase) {
                   //添加牌的花色
                   map.put(index,n+s);  //序号以及牌
                   index++;
               }
           }

           //还有大王 /小王
           map.put(index,"小王");
           index++;
           map.put(index,"大王");

       }


    public overGame() {
//        System.out.println(map);
        //1.将牌盒序号加入 ArrList 集合
        Set<Integer> integers = map.keySet();
        for (Integer in : integers) {
            ArrList.add(in);
        }

        //2.打乱顺序【洗牌】
        Collections.shuffle(ArrList);


        //发牌跟准备各自的牌集合【TreeSet集合有排序的作用】
        TreeSet<Integer> lord=new TreeSet<>();
        TreeSet<Integer> palyer1=new TreeSet<>();
        TreeSet<Integer> palyer2=new TreeSet<>();
        TreeSet<Integer> palyer3=new TreeSet<>();



        for (int i = 0; i < ArrList.size(); i++) {
           int num= ArrList.get(i);
            if(i<3){  //底牌
                lord.add(num);
                continue;
            }

            //轮流发牌给三个人
            if(i%3==0){
                palyer1.add(num);
            }else if(i%3==1){
                palyer2.add(num);
            }else if(i%3==2){
                palyer3.add(num);
            }
        }

        //看牌
        lookPoker("地主",lord);  //底牌
        lookPoker("唯易",palyer1);  //玩家1
        lookPoker("大帅哥",palyer2);  //玩家2
        lookPoker("大SB",palyer3);  //玩家3
    }

    public void lookPoker(String name,TreeSet<Integer> lists){
        //将序号的数据经过map遍历获取到值，添加到集合中
        ArrayList<String> New=new ArrayList<>();

        System.out.println();
        System.out.print(name+"的牌=");
        for (Integer list : lists) {
            String val = map.get(list);  //根据键获取相对应的值
            New.add(val);  //将值添加到New集合中

        }
        for (String s : New) {  //遍历New集合输出牌
            System.out.print(s+"\t");
        }
    }
}

package com.Lucky.AppUnit;
import java.util.*;

/*
高级版 ：利用自定义价值排序
 */
public class valuesGame {
        //1.准备一副扑克牌
       static ArrayList<String> array=new ArrayList<>();   //牌盒
       static TreeMap<String,Integer> List=new TreeMap<>();  //自定义价值盒子

       //利用代码块加载:与类一起加载，只加载一次
    static{
        //定义花色
           String[] huase={"♠","♥","♦","♣"};
       //定义牌面数字
           String[] num={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};


           //遍历添加牌
           for (String s : num) {
               //遍历添加牌的数字
               for (String n : huase) {
                   //添加牌的花色
                   array.add(n+s);  //序号以及牌
               }
           }

           //还有大王 /小王
           array.add(" 小王"); //前面的空格是用于统一截取字符串的要求
           array.add(" 大王");

       }


    public valuesGame() {
        List.put("J",20);
        List.put("Q",21);
        List.put("K",22);
        List.put("A",23);
        List.put("2",24);
        List.put("大王",30);
        List.put("小王",50);



        //2.打乱顺序【洗牌】
        Collections.shuffle(array);


        //发牌跟准备各自的牌集合
        ArrayList<String> lord=new ArrayList<>();
        ArrayList<String> palyer1=new ArrayList<>();
        ArrayList<String> palyer2=new ArrayList<>();
        ArrayList<String> palyer3=new ArrayList<>();


        //发牌
        for (int i = 0; i < array.size(); i++) {
            String str=array.get(i);  //实际牌面的数字
            if(i<3){  //底牌
                lord.add(str);
                continue;
            }
            //轮流发牌给三个人
            if(i%3==0){
                palyer1.add(str);
            }else if(i%3==1){
                palyer2.add(str);
            }else if(i%3==2){
                palyer3.add(str);
            }
        }

        //看牌
        lookPoker("地主",lord);  //底牌
        lookPoker("唯易",palyer1);  //玩家1
        lookPoker("大帅哥",palyer2);  //玩家2
        lookPoker("大SB",palyer3);  //玩家3
    }

    public void lookPoker(String name,ArrayList<String> lists){
        //再将lists集合中的数字排序
        lists.sort(new Comparator<String>() {
            @Override
            //Array.sort[插入排序+二分排序]
            public int compare(String o1, String o2) {
                /*
                 o1：代表现在要添加的数据
                 o2：已经存储在集合中的数据
                 */
               //计算花色和价值
                String color = o1.substring(0, 1);
                int val=getValue(o1);

                String color1 = o2.substring(0, 1);
                int val1=getValue(o2);

               //比价价值
                int i=val-val1;
                return i==0 ? color.compareTo(color1):i;  //价值相同，就比较花色大小
            }
        });

        //输出牌面
        System.out.print(name+"的牌=");
        System.out.println(lists);

    }

    //计算价值的方法
    public static int getValue(String str){
             //获取数字
            String sub = str.substring(1);

            //判断获取的数字在map集合中是否存在
         //注意点：存在大王/小王的Bug，要统一截取，令其在集合中存在
            if(List.containsKey(sub)){
                //存在，就获取值
                return List.get(sub);
            }else {
                //不存在，就将键强制转换成价值【int】类型作为价值
                return Integer.parseInt(sub);

            }
    }
}

标签：map,String,斗地主,int,ArrayList,System,案例,集合,new
From： https://www.cnblogs.com/Lucky-only/p/16975526.html

相关文章

赞助商

阅读排行