1. package cn.itcast;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Collections;
   
5. import java.util.HashMap;
   
6. import java.util.TreeSet;
   
7. 
   
8. /*
   
9. * 三个人斗地主
   
10. * 分析：
    
11. * 首先要有牌，牌有花色和面值，另有大小王各一张
    
12. * 所以分别用数组定义花色和面值
    
13. *
    
14. * 有了牌以后要进行储存
    
15. *
    
16. * 储存以后，打乱牌的顺序，按乱序以后顺序发牌
    
17. *
    
18. * 分别依次发给三个人，在发到还有三张牌的时候留作底牌
    
19. *
    
20. * 发牌结束进行看牌
    
21. *
    
22. * 这个时候发现一个问题，牌的排列很乱，这样不利于我们看
    
23. * 于是从更加细致的角度来思考这个问题
    
24. *
    
25. * 定义牌的大小，每张牌对应一个索引，存入Map集合中
    
26. * 在排序和发牌时，只是对索引进行操作
    
27. * 在看牌时，显示已按大小顺序排好索引对应的值
    
28. *
    
29. * 步骤：
    
30. * 1.定义HashMap集合，定义ArrayList集合
    
31. * 2.定义两个数组，花色和面值
    
32. * 3.定义索引，将索引和牌存入Map，索引存入ArrayList
    
33. * 4.对ArrayList进行乱序
    
34. * 5.按照索引对每一张牌进行发放
    
35. * 6.定义功能看牌
    
36. *
    
37. */
    
38. public class PokerDemo2 {
    
39. 
    
40.         public static void main(String[] args) {
    
41. 
    
42.                 // 定义集合
    
43.                 HashMap<Integer, String> hm = new HashMap<Integer, String>();
    
44. 
    
45.                 ArrayList<Integer> al = new ArrayList<Integer>();
    
46. 
    
47.                 // 定义数组
    
48.                 String[] huase = { "♥", "♠", "♧", "♢" };
    
49.                 String[] mianzhi = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
    
50.                                 "K", "A", "2" };
    
51. 
    
52.                 // 定义索引存入集合
    
53.                 int index = 0;
    
54. 
    
55.                 // 外循环应该是数值，内循环是花色，这个是牌的大小决定的
    
56.                 for (String num : mianzhi) {
    
57.                         for (String color : huase) {
    
58.                                 hm.put(index, color.concat(num));
    
59.                                 al.add(index);
    
60.                                 index++;
    
61. 
    
62.                         }
    
63.                 }
    
64.                 // 两张特殊的牌
    
65.                 hm.put(index, "小王");
    
66.                 al.add(index);
    
67.                 index++;
    
68.                 hm.put(index, "大王");
    
69.                 al.add(index);
    
70. 
    
71.                 // 牌已经装好，现在需要打乱顺序，只需要对ArrayList操作
    
72.                 Collections.shuffle(al);
    
73. 
    
74.                 // 发牌，对每一张牌的索引进行处理，希望可以自动排序，就使用TreeSet进行存储
    
75.                 TreeSet<Integer> player1 = new TreeSet<Integer>();
    
76.                 TreeSet<Integer> player2 = new TreeSet<Integer>();
    
77.                 TreeSet<Integer> player3 = new TreeSet<Integer>();
    
78.                 TreeSet<Integer> retain = new TreeSet<Integer>();
    
79. 
    
80.                 for (int x = 0; x < al.size(); x++) {
    
81. 
    
82.                         // 需要留三张底牌
    
83.                         if (x >= al.size()-3) {
    
84.                                 retain.add(al.get(x));
    
85.                         } else if (x % 3 == 0) {
    
86.                                 player1.add(al.get(x));
    
87.                         } else if (x % 3 == 1) {
    
88.                                 player2.add(al.get(x));
    
89.                         } else if (x % 3 == 2) {
    
90.                                 player3.add(al.get(x));
    
91.                         }
    
92.                 }
    
93. 
    
94.                 // 发牌结束，想要看看玩家的牌，可以定义功能实现
    
95. 
    
96.                 // 想看谁的牌就可以看了
    
97.                 lookPocker("玩家1", player1, hm);
    
98.                 lookPocker("玩家2", player2, hm);
    
99.                 lookPocker("玩家3", player3, hm);
    
100.                 lookPocker("留底", retain, hm);
     
101. 
     
102.         }
     
103. 
     
104.         /*
     
105.          * 两个明确：应该是没有具体返回值类型的，因为是看牌，直接输出结果即可。
     
106.          * 参数列表的思考：看谁的牌，需要调用TreeSet和HashMap两个集合，因为看牌需要输出牌而不是索引
     
107.          */
     
108. 
     
109.         public static void lookPocker(String name, TreeSet<Integer> ts,
     
110.                         HashMap<Integer, String> hm) {
     
111. 
     
112.                 System.out.print(name + "的牌:");
     
113. 
     
114.                 for (Integer key : ts) {
     
115.                         String value = hm.get(key);
     
116.                         System.out.print(value + " ");
     
117.                 }
     
118.                 System.out.println();
     
119.         }
     
120. }
     

复制代码

你是真不怕出乱码啊！

女神从来不加班 发表于 2015-3-20 16:53
你是真不怕出乱码啊！

用eclipse写编码表转utf-8就可以了呀

明羽果果 发表于 2015-3-20 19:51
用eclipse写编码表转utf-8就可以了呀

哈哈 我知道 我就看那四个花色就是乱码的苗头哈

女神从来不加班 发表于 2015-3-20 20:00
哈哈 我知道 我就看那四个花色就是乱码的苗头哈

:lol是的，我用输入法随便弄的