使用打乱算法洗牌,发牌               
提示：需要两个数组
数组1：定义一副牌
数组2：确定玩家,斗地主{"沈春阳","张柏芝","林青霞"}
* 洗牌
* 发牌：0，1，2   牌%

1. /*题目：使用打乱算法洗牌,发牌               
   
2.         提示：需要两个数组
   
3.                   数组1：定义一副牌
   
4.                   数组2：确定玩家,斗地主{"沈春阳","张柏芝","林青霞"}
   
5.                   洗牌
   
6.                   发牌：0，1，2   牌%
   
7. 
   
8. 思路和步骤：1.首先应该生成一副扑克牌，扑克牌的规律是有2到10以及J,Q,K,A,小王和大王。可以将它们定义在一个字符串数组中。
   
9.            2.接着是洗牌。洗牌是随机事件，可以想到随机数发生器Random。通过多次循环随机抽取定义的扑克牌数组中的元素
   
10.              进行交换位置来达到洗牌效果。
    
11.            3.最后是发牌。发牌可以通过定义4个动态数组即arraylist来分别对应3个玩家和最后的底牌。我们通过循环遍历的方式将洗好
    
12.              的牌按规则添加到4个arraylist中去。再打印输出。
    
13. */
    
14. import java.util.*;
    
15. 
    
16. class Test2 {
    
17. 
    
18. /*
    
19. 生成一副扑克牌
    
20. */
    
21.         public static String[] poker()
    
22.         {
    
23.                 String[] s1 = { "黑桃", "红桃", "梅花", "方片" };
    
24.                 String[] s2 = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
    
25.                 String[] s3 = { "小王", "大王" };
    
26.                 String[] s4 = new String[54];
    
27.                 s4[52] = s3[0];
    
28.                 s4[53] = s3[1];
    
29. 
    
30.                 for (int i = 0; i < 52; i++) {
    
31.                         s4[i] = s1[i % 4] + s2[i / 4];
    
32.                 }
    
33.                 return s4;
    
34.         }
    
35. 
    
36. /*
    
37. 洗牌
    
38. */
    
39.         public static String[] shuffle(String[] s2)
    
40.         {
    
41.                 for (int i = 0; i < 100; i++)
    
42.                 {
    
43.                         String k;
    
44.                         Random ran = new Random();
    
45.                         int ran1 = ran.nextInt(54);
    
46.                         int ran2 = ran.nextInt(54);
    
47.                 //通过随机抽取两张牌的位置进行交换来进行洗牌。
    
48.                         k = s2[ran1];
    
49.                         s2[ran1] = s2[ran2];
    
50.                         s2[ran2] = k;
    
51.                 }
    
52.                 return s2;
    
53.         }
    
54. /*
    
55. 斗地主发牌，最后留三张。
    
56. */
    
57.         public static void deal(String[] s1)
    
58.         {
    
59.                 ArrayList<String> wanjia1 = new ArrayList<String>();
    
60.                 ArrayList<String> wanjia2 = new ArrayList<String>();
    
61.                 ArrayList<String> wanjia3 = new ArrayList<String>();
    
62.                 ArrayList<String> dipai = new ArrayList<String>();
    
63. 
    
64.                 for (int i = 0; i < 54; i++)
    
65.                 {
    
66. 
    
67.                         int k = i % 3;
    
68.                         if(i>50)
    
69.                                 dipai.add(s1[i]);
    
70.                         else if (k == 0)
    
71.                                 wanjia1.add(s1[i]);
    
72.                         else if (k == 1)
    
73.                                 wanjia2.add(s1[i]);
    
74.                         else
    
75.                                 wanjia3.add(s1[i]);
    
76.                        
    
77.                                
    
78.                 }
    
79.                 System.out.println("沈春阳的牌："+wanjia1+"\n"+"\n"+"张柏芝的牌:"+wanjia2+"\n"+"\n"+"林青霞的牌:"+wanjia3+"\n"+"\n"+"底牌:"+dipai);
    
80.         }
    
81. /*
    
82. main函数调用执行进行洗牌和发牌功能。
    
83. */
    
84.         public static void main(String[] args)
    
85.         {
    
86.                 String[] s1 =new String[54];
    
87.                 s1 = poker();        //生成一副牌。
    
88.                 shuffle(s1);                //洗牌。
    
89.                 deal(s1);                //发牌。
    
90.         }
    
91. }

复制代码

这是运行结果

有意思，我前两天刚写洗牌，发牌的程序，“斗地主”和“升级”（一副牌的）。在这里看到了。
顶一下！
楼上写的比较好，我是直接用Collections里面的shuffle()方法，没有自己写。

import java.util.*;

class Demo04
{
        public static void main(String[] args)
        {
                        Random r =new Random();
                       
                         String[] s ={"1","2","3","4","5","6","7","8","9","10","j","q","k","jorker","JORKER"};
                         //为了简化，只定义了15张扑克
                         for (int j=s.length-1;j>=0 ;j-- )
                         {
                                 int index=r.nextInt(s.length);//使用随机函数将扑克牌进行打乱
                                 String temp ="0";
                                 temp=s[j];
                                 s[j]=s[index];
                                 s[index]=temp;

                         }
                        System.out.println(Arrays.toString(s));

                        String[] s1=new String [5]; //定义三个玩家数组。
                        String[] s2=new String [5];
                        String[] s3=new String [5];

                        int i =0;
                        int a=0;
                        int b=0;
                        int c=0;
                        //个人感觉此处应该能有所简化，但是想不出更好的方法了，希望能一起探讨

                        for (i=0;i<15 ;i++ )
                        {
                               
                                if (i%3==0)
                                {
                                        s1[a]=s[i];
                                        a++;
                                }
                                if (i%3==1)
                                {
                                        s2[b]=s[i];
                                        b++;
                                }
                                if (i%3==2)
                                {
                                        s3[c]=s[i];
                                        c++;
                                }
                        }
                        System.out.println("s1="+Arrays.toString(s1));//分别打印三个玩家获得的手牌
                        System.out.println("s2="+Arrays.toString(s2));
                        System.out.println("s3="+Arrays.toString(s3));
        }
}



楼主，因为我暂时只学到了数组的相关知识，后面容器的用法并不了解，所以用最基本的知识粗糙的解答此题，（例如定义的扑克只有15张，没有留底牌等），希望能一起探讨学习。

1. import java.util.*;
   
2. class  Test02
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                
   
7.                 newPk();
   
8.         }
   
9. /*思考：
   
10.                 使用打乱算法洗牌,发牌               
    
11.                 提示：需要两个数组
    
12.                 数组1：定义一副牌
    
13.                 数组2：确定玩家,斗地主{"沈春阳","张柏芝","林青霞"}
    
14.                 * 洗牌
    
15.                 * 发牌：0，1，2   牌%3
    
16. */
    
17. 
    
18.         public static void newPk()
    
19.         {
    
20.         //定义一副牌，用数组
    
21.                 String[] pk = {"红桃A","黑桃A","方块A","梅花A","红桃2","黑桃2","方块2","梅花2",
    
22.                         "红桃3","黑桃3","方块3","梅花3","红桃4","黑桃4","方块4","梅花4",
    
23.                         "红桃5","黑桃5","方块5","梅花5","红桃6","黑桃6","方块6","梅花6",
    
24.                         "红桃7","黑桃7","方块7","梅花7","红桃8","黑桃8","方块8","梅花8",
    
25.                         "红桃9","黑桃9","方块9","梅花9","红桃10","黑桃10","方块10","梅花10",
    
26.                         "红桃J","黑桃J","方块J","梅花J","红桃Q","黑桃Q","方块Q","梅花Q",
    
27.                         "红桃K","黑桃K","方块K","梅花K","jorker","JORKER"};
    
28.                 //首先将牌随机洗乱，然后用一数组储存
    
29.                 String[] arr = new String[54];
    
30.                 boolean[] base = new boolean[54];
    
31.                 int a = 0;
    
32.                 do
    
33.                 {
    
34.                         Random r = new Random();
    
35.                         int temp = r.nextInt(arr.length);
    
36.                         if(!base[temp])
    
37.                         {
    
38.                                 arr[a++] = pk[temp];
    
39.                                 base[temp] = true;
    
40.                         }
    
41.                 }
    
42.                 while (a<pk.length);
    
43.                 //需要将洗好的牌按顺序发给3个人，我们用三个数组来储存
    
44.                 String[] name1 = new String[17];
    
45.                 String[] name2 = new String[17];
    
46.                 String[] name3 = new String[17];
    
47.                 int i=0,j=0,k=0;
    
48.                 for (int x = 0; x<51;x++ )
    
49.                 {
    
50.                         if(x%3==0)
    
51.                         {
    
52.                          name1[i++] = arr[x];
    
53.                         }
    
54.                         if(x%3==1)
    
55.                         {
    
56.                         name2[j++] = arr[x];
    
57.                         }
    
58.                         if(x%3==2)
    
59.                         {
    
60.                         name3[k++] = arr[x];
    
61.                         }
    
62.                 }
    
63.                 System.out.println(Arrays.toString(arr));//洗后的牌
    
64.                 System.out.println("--------------------------------------------------------");
    
65.                 System.out.println(Arrays.toString(name1));//第一个人的牌
    
66.                 System.out.println("--------------------------------------------------------");
    
67.                 System.out.println(Arrays.toString(name2));//第二个人的牌
    
68.                 System.out.println("--------------------------------------------------------");
    
69.                 System.out.println(Arrays.toString(name3));//第三个人的牌
    
70.                 //还需要定义一个数组来装最后三张牌，也是按顺序
    
71.                 System.out.println("--------------------------------------------------------");
    
72.                 String[] lastPk = new String[3];
    
73.                 lastPk[0] = arr[51];
    
74.                 lastPk[1] = arr[52];
    
75.                 lastPk[2] = arr[53];
    
76.                 System.out.println(Arrays.toString(lastPk));
    
77.         }
    
78. 
    
79. }

复制代码

上面楼层的，我也是刚学到数组，但是我好像定义的数组太多了

lei 发表于 2014-2-20 11:25

思路清晰，给力。