a

1. /**
   
2. * 需求：模拟实现斗地主的分牌情形
   
3. * 分析：        1 模拟牌盒，存储54张牌，0-53 每个数字分别对应一张牌，用Map存储
   
4. *                         2 将0-53序号随机分发到三个人手中，欲实现序号的随机排序，考虑使用Collections.shuffle()
   
5. *                         因此序号使用ArrayList存储
   
6. *                         3 看牌，并且实现玩家手上的拍由小到大排序，所以考虑使用TreeSet存储
   
7. */
   
8. package fmi1;
   
9. 
   
10. import java.util.ArrayList;
    
11. import java.util.Collections;
    
12. import java.util.HashMap;
    
13. import java.util.TreeSet;
    
14. 
    
15. public class PokerSimulate {
    
16. 
    
17.         /**
    
18.          * @param args
    
19.          */
    
20.         public static void main(String[] args) {
    
21.                 //建立牌盒
    
22.                 String[] color = {"♦","♣","♥","♠"};//花色
    
23.                 String[] size ={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};//大小
    
24.                 //建立集合存牌
    
25.                 HashMap<Integer, String> hm = new HashMap<Integer,String>();
    
26.                 //循环组牌并存至集合
    
27.                 int key = 0;
    
28.                 for(String s1:size){
    
29.                         for(String s2:color){
    
30.                                 String value = s2 + s1;
    
31.                                 hm.put(key, value);
    
32.                                 key++;
    
33.                         }
    
34.                 }
    
35.                 hm.put(key++, "LKing");
    
36.                 hm.put(key, "BKing");
    
37.                 //输出牌
    
38.                 printPoke(hm);
    
39.                 //建立ArrayList实现牌的序号的随机分布
    
40.                 ArrayList<Integer> al = new ArrayList<Integer>();
    
41.                 //存序号
    
42.                 for(int i = 0;i < 54;i++){
    
43.                         al.add(i);
    
44.                 }
    
45.                 //洗牌
    
46.                 Collections.shuffle(al);
    
47.                 //新建3个玩家和一个底牌，即TreeSet集合
    
48.                 TreeSet<Integer> gamer1 = new TreeSet<Integer>();
    
49.                 TreeSet<Integer> gamer2 = new TreeSet<Integer>();
    
50.                 TreeSet<Integer> gamer3 = new TreeSet<Integer>();
    
51.                 TreeSet<Integer> dipai = new TreeSet<Integer>();
    
52.                 //发牌
    
53.                 for(int i = 0;i<al.size();i++){
    
54.                         if(i >= al.size()-3)
    
55.                                 dipai.add(al.get(i));
    
56.                         else if(i%3==0)
    
57.                                 gamer1.add(al.get(i));
    
58.                         else if(i%3==1)
    
59.                                 gamer2.add(al.get(i));
    
60.                         else
    
61.                                 gamer3.add(al.get(i));
    
62.                 }
    
63. //                System.out.println(gamer1);
    
64. //                System.out.println(gamer2);
    
65. //                System.out.println(gamer3);
    
66. //                System.out.println(dipai);
    
67.                 //看牌
    
68.                 System.out.println("玩家1:");
    
69.                 checkPoker(gamer1,hm);
    
70.                 System.out.println("玩家2:");
    
71.                 checkPoker(gamer2,hm);
    
72.                 System.out.println("玩家3:");
    
73.                 checkPoker(gamer3,hm);
    
74.                 System.out.println("底牌:");
    
75.                 checkPoker(dipai,hm);
    
76.         }
    
77. 
    
78.         private static void checkPoker(TreeSet<Integer> gamer,
    
79.                         HashMap<Integer, String> hm) {
    
80.                 for(int key:gamer){
    
81. //                        System.out.print(key+" ");
    
82.                         System.out.print(hm.get(key)+" ");
    
83.                 }
    
84.                 System.out.println();
    
85.                
    
86.         }
    
87. 
    
88.         private static void printPoke(HashMap<Integer, String> hm) {
    
89.                 System.out.print("扑克牌：");
    
90.                 for (int i = 0; i < hm.size(); i++) {
    
91.                         if (i % 4 == 0)
    
92.                                 System.out.println();
    
93.                         System.out.print(hm.get(i) + "\t");
    
94.                 }
    
95.                 System.out.println();
    
96.         }
    
97. 
    
98. }
    

复制代码

抓紧努力中

♥♣♦♠

fjb0902 发表于 2015-9-9 20:41
好帖好帖好帖，重要的说了三遍

谢谢 谢谢 谢谢

好帖好帖好帖，重要的说了三遍

我来了 发表于 2015-9-9 20:03
还没学到，顿时感觉亚历山大

哈 学到了  你就会发现其实没那么难  就是把几部分的内容合一块

李振在黑马 发表于 2015-9-9 17:06
哇哦！看来就业班很充实啊。提前准备把。

(⊙o⊙)…这是基础班的内容

还没学到，顿时感觉亚历山大

不错啊！！

哇哦！看来就业班很充实啊。提前准备把。

学习了········

fmi110 发表于 2015-9-7 21:47
你就业班上到第几天了？是北京校区？

还有两个月,北京

cemabenteng 发表于 2015-9-7 21:45
进度非常快,特别快,每天敲不完的代码,好好珍惜基础班轻松的时间吧

话说 你还有时间逛论坛啊

cemabenteng 发表于 2015-9-7 21:45
进度非常快,特别快,每天敲不完的代码,好好珍惜基础班轻松的时间吧

你就业班上到第几天了？是北京校区？

fmi110 发表于 2015-9-7 21:41
你已在就业班？？感觉怎么样啊？

进度非常快,特别快,每天敲不完的代码,好好珍惜基础班轻松的时间吧

cemabenteng 发表于 2015-9-7 21:36
加油吧!!!

你已在就业班？？感觉怎么样啊？

fmi110 发表于 2015-9-6 11:12
对头

加油吧!!!

好吧 还没学到

枕草虫 发表于 2015-9-6 15:30
多谢楼主，学习了，来交作业

写的很好  都封装进函数了

1. package Test;
   
2. import java.util.*;
   
3. /**
   
4. * 思路：
   
5. * 1、        建立54张牌,然后存放到List集合当中打乱
   
6. * 2、        将54张牌遍历致51号，分别存入3个TreeSet集合当中，将剩下的存入令一个集合当中
   
7. * 3、        遍历3个集合，与底牌集
   
8. * 然而输出的时候，顺序不对
   
9. *
   
10. * 那么想到楼主的思路，先建立一个从小到大顺序的集合，然后将打乱的脚标 分给三个玩家
    
11. *
    
12. *思路：
    
13. *1、建立牌堆：建立ArrayList集合，将数字+花色 作为一个元素 按照从3-K-A-2，还有小王，大王的顺序存储到集合当中
    
14. *2、发牌：建立一个脚标集合，利用Collections.shuffle(list)方法，然后将打乱的脚标分给三个玩家，然后拿着分好的脚标去牌堆中找元素
    
15. *3、因为最后输出还是要排序，所以玩家使用TreeSet集合
    
16. * */
    
17. public class PockeDemo {
    
18. 
    
19.         public static void main(String[] args) {
    
20.                 // TODO Auto-generated method stub
    
21.                 //建立牌堆
    
22.                 List<String> li = creatPoker();
    
23.                
    
24.                 //建立脚标集合
    
25.                 ArrayList<Integer> al = new ArrayList<Integer>();
    
26.                 for(int i = 0 ;i < 54; i++)
    
27.                         al.add(i);
    
28.                 //打乱脚标集合的顺序
    
29.                 Collections.shuffle(al);
    
30.                
    
31.                 //将脚标分给三个玩家
    
32.                 TreeSet<Integer> gamer1 = new TreeSet<Integer>();
    
33.                 TreeSet<Integer> gamer2 = new TreeSet<Integer>();
    
34.                 TreeSet<Integer> gamer3 = new TreeSet<Integer>();
    
35.                 TreeSet<Integer> dipai = new TreeSet<Integer>();
    
36.                
    
37.                 fenPeiIndex(al,gamer1,gamer2,gamer3,dipai);
    
38.                
    
39.                
    
40.                 //遍历每个玩家的脚标，并到洗好的牌中去找
    
41.                 System.out.println("玩家1：");
    
42.                 zhuaPai(li,gamer1);
    
43.                 System.out.println();
    
44.                
    
45.                 System.out.println("玩家2：");
    
46.                 zhuaPai(li,gamer2);
    
47.                 System.out.println();
    
48.                
    
49.                 System.out.println("玩家3：");
    
50.                 zhuaPai(li,gamer3);
    
51.                 System.out.println();
    
52.                
    
53.                 System.out.println("底牌：");
    
54.                 zhuaPai(li,dipai);
    
55.                
    
56.         }
    
57.        
    
58.        
    
59.         //建立顺序的牌
    
60.         public static List<String> creatPoker(){
    
61.                 ArrayList<String> al = new ArrayList<String>();
    
62.                
    
63.                 String[] color = {"♦","♣","♥","♠"};
    
64.                 String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
    
65.                
    
66.                 for(String s1 : num)
    
67.                         for(String s2 : color)
    
68.                                 al.add(s1+s2);
    
69.                
    
70.                 al.add("小王");
    
71.                 al.add("大王");
    
72.                
    
73.                 return al;
    
74.         }
    
75.         //分配脚标给玩家
    
76.         public static void fenPeiIndex(ArrayList<Integer> al,
    
77.                                                         TreeSet<Integer> gamer1,
    
78.                                                         TreeSet<Integer> gamer2,
    
79.                                                         TreeSet<Integer> gamer3,
    
80.                                                         TreeSet<Integer> dipai){
    
81.                
    
82.                 int count = 0;
    
83.                 for(int i : al){
    
84.                         if(count<51){
    
85.                                 if(count%3 == 0)
    
86.                                         gamer1.add(i);
    
87.                                 else if(count%3 == 1)
    
88.                                         gamer2.add(i);
    
89.                                 else
    
90.                                         gamer3.add(i);
    
91.                         }
    
92.                         else
    
93.                                 dipai.add(i);
    
94.                         count++;
    
95.                 }
    
96.                
    
97.         }
    
98.         //抓牌
    
99.         public static void zhuaPai(List<String> li,TreeSet<Integer> gamer){
    
100.                 for(int i : gamer){
     
101.                         System.out.print(li.get(i)+"\t");
     
102.                 }
     
103.         }
     
104. }

复制代码

多谢楼主，学习了，来交作业