集合之斗地主案例

复制代码
 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 }
复制代码
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
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");
        }
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
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");
        }
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
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");
        }
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
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);
 
            }
    }
}

　　

posted @   唯易人生  阅读(67)  评论(0)  编辑  收藏  举报
相关博文：
· 集合之Set【TreeSet】
· 集合之Collections工具类
· 集合（模拟斗地主发牌）
· 斗地主集合案例
· Java集合详解
阅读排行：
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
点击右上角即可分享
微信分享提示