有JAVA编写程序,左手有13张牌梅花2-A,右手13张红心2-A,洗牌右手的每张压在左手的每张上，

代码：

/

  纸牌

  @author lina

 /

public class Card {

/

  boolean型，false为梅花，true为红桃

 /

private final boolean type;

/

  int型，牌值

 /

private final int number;

/

  构造函数

  @param type boolean型，false为梅花，true为红桃

  @param number int型，牌值

 /

public Card(boolean type, int number) {

thistype = type;

thisnumber = number;

}

public String toString() {

String t = "";

String v = "";

if(!thistype) {

t = "梅花";

} else {

t = "红桃";

}

if(thisnumber == 1) {

v = "A";

} else if(thisnumber == 11) {

v = "J";

} else if(thisnumber == 12) {

v = "Q";

} else if(thisnumber == 13) {

v = "K";

} else {

v = thisnumber + "";

}

String back = t + v;

return back;

}

public boolean isType() {

return type;

}

public int getNumber() {

return number;

}

}package program3;

/

  主程序

  @author lina

 /

public class Main {

/

  构造初始卡组：

  0～12为左手的梅花2～A

  13～25为右手的红桃2～A

 /

private static Card[] create_cards() {

Card[] back = new Card[26];

for(int i = 0; i < backlength; i++) {

// 为梅花

if(i / 13 == 0) {

if (i == 12) {

back[i] = new Card(false, 1);

} else {

back[i] = new Card(false, i + 2);

}

}

// 为红桃

if(i / 13 == 1) {

if(i == 25) {

back[i] = new Card(true, 1);

} else {

back[i] = new Card(true, i % 13 + 2);

}

}

}

return back;

}

/

  分作输出卡组

  @param cards

 /

private static void show(Card[] cards) {

Systemoutprint("左手牌组：");

for(int i = 0; i <= 11; i++) {

Systemoutprint(cards[i] + ",");

}

Systemoutprint(cards[12]);

Systemoutprintln();

Systemoutprint("右手牌组：");

for(int i = 13; i <= 24; i++) {

Systemoutprint(cards[i] + ",");

}

Systemoutprint(cards[25]);

Systemoutprintln();

}

/

  进行一次洗牌

  @param cards Card[]型，待洗牌组

  @return Card[]型，洗牌后的牌组

 /

private static Card[] shuffle(Card[] cards) {

Card[] back = new Card[cardslength];

for(int i = 0; i < cardslength / 2; i++) {

back[2  i] = cards[i + 13];

back[2  i + 1] = cards[i];

}

return back;

}

public static void main(String[] args) {

Card[] cards = create_cards();

Systemoutprintln("初始时：");

show(cards);

// int count = 0; // 洗牌次数

// do {

// count++;

// cards = shuffle(cards);

// } while(cards[0]isType() || (!cards[0]isType() && cards[0]getNumber() != 2));

// Systemoutprintln("第" + count + "次洗牌后：");

// show(cards);

       int count = 1;   // 循环洗牌次数

       int realCount = count % 18; // 每洗18次牌牌组将恢复初始

        for(int i = 0; i < realCount; i++) {

            cards = shuffle(cards);

        }

        Systemoutprintln("第" + count + "轮洗牌后：");

        show(cards);

}

}

注意：每洗18次牌牌组是会复原的，因此无论洗多少次牌，我们在计算时总可以控制在洗18次之内！！！又因为牌组的大小固定为26张，则本算法的时间复杂度将为常数阶O(1),否则时间复杂度将与洗牌次数有关变为恐怖的O(n)。

我使用了一个辅助数组，因为牌组长度固定为26，因此也无所谓了，空间复杂度也是O(1)

以下是洗7次牌时的测试数据：

初始时：

左手牌组：梅花2,梅花3,梅花4,梅花5,梅花6,梅花7,梅花8,梅花9,梅花10,梅花J,梅花Q,梅花K,梅花A

右手牌组：红桃2,红桃3,红桃4,红桃5,红桃6,红桃7,红桃8,红桃9,红桃10,红桃J,红桃Q,红桃K,红桃A

第7轮洗牌后：

左手牌组：红桃J,红桃7,红桃3,梅花Q,梅花8,梅花4,红桃A,红桃10,红桃6,红桃2,梅花J,梅花7,梅花3

右手牌组：红桃K,红桃9,红桃5,梅花A,梅花10,梅花6,梅花2,红桃Q,红桃8,红桃4,梅花K,梅花9,梅花5

然后是洗18次牌时（变回初始了）：

初始时：

左手牌组：梅花2,梅花3,梅花4,梅花5,梅花6,梅花7,梅花8,梅花9,梅花10,梅花J,梅花Q,梅花K,梅花A

右手牌组：红桃2,红桃3,红桃4,红桃5,红桃6,红桃7,红桃8,红桃9,红桃10,红桃J,红桃Q,红桃K,红桃A

第18轮洗牌后：

左手牌组：梅花2,梅花3,梅花4,梅花5,梅花6,梅花7,梅花8,梅花9,梅花10,梅花J,梅花Q,梅花K,梅花A

右手牌组：红桃2,红桃3,红桃4,红桃5,红桃6,红桃7,红桃8,红桃9,红桃10,红桃J,红桃Q,红桃K,红桃A

先看第三个循环，牌的花色是值除以13，牌的值是对13取余

所以在看第一个循环，每一个牌都被赋值，从0到51

0表示花色是（0）spades，点数是ACE，1表示花色是sapdes，点数是2

以此类推，相当于第一个循环就是把一副牌的花色分开，点数从小到大排列，用序号表示每张牌

第二个循环就是随机一个序号，然后交换值，相当于洗牌

第三个循环就是输出最上面的四张牌的花色和点数

java内的Collections类自带了一个shuffle洗牌算法。

static void shuffle(List<> list)

使用默认随机源对指定列表进行置换。

static void shuffle(List<> list, Random rnd)

使用指定的随机源对指定列表进行置换。

现在你可以把52张牌放进一个List里，调用他的shuffle算法打乱顺序。

首先实现洗牌，最简单的方法是选用不记录顺序的集合，这种集合不会记录实体插入顺序，你只需要把实体都插进去再遍历取出来就已经是乱序的了。HashMap是个不错的选择，记得使用entry进行遍历。

import javautilArrayList;

import javautilRandom;

public class PokerDemo {

ArrayList<Card> poker = new ArrayList<Card>();

Player[] players;

int n = 4;

String[] name = {"Wang", "Zhang", "Li", "Yuan"};

public PokerDemo() {

players = new Player[n];

for(int i = 0; i < playerslength; i++)

players[i] = new Player(name[i]);

for(int i = 0; i < 4; i++)

for(int j = 0; j < 13; j++)

pokeradd(new Card(i, j));

Systemoutprintln("洗牌前: " + poker);

xipai();

Systemoutprintln("洗牌后: " + poker);

fapai();

Systemoutprintln("发牌后: ");

for(int i = 0; i < playerslength; i++)

Systemoutprintln(players[i]);

}

public void xipai() {

Random r = new Random();

ArrayList<Card> tmp = new ArrayList<Card>();

while(!pokerisEmpty()) {

int index = rnextInt(pokersize());

Card card = pokerget(index);

tmpadd(card);

pokerremove(index);

}

poker = new ArrayList<Card>(tmp);

}

public void fapai() {

int p = 0;

while(!pokerisEmpty()) {

Card card = pokerget(0);

players[p]add(card);

p = (p + 1) % n;

pokerremove(0);

}

}

public static void main(String[] args) {

new PokerDemo();

}

}

class Card {

int val, sty;

final String[] value = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};

final String[] style = {"黑桃", "红心", "梅花", "方块"};

public Card(int s, int v) {

sty = s;

val = v;

}

public String toString() {

return style[sty]+ " " + value[val];

}

}

class Player {

ArrayList<Card> cards = new ArrayList<Card>();

String name;

public Player(String n) {

name = n;

}

public void add(Card card) {

cardsadd(card);

}

public String toString() {

return name + ":\t" + cards;

}

}

//给你个思路:给要给随机值,该随机值在索引范围内,然后从索引值里面取元素,在该元素对应

//的位置,进行二次随机取其他元素,然后进行交换,就可以了!

//还有更简单的办法,java早就想到了这一点,在集合工具里面就提供该方法,其实他内部也是

//这样的思路,用随机值进行交换!

import javautil;

public class ArrayListTest {

public static void main(String[] args) {

Integer[] arr=new Integer[10];

for (int i = 0; i < arrlength; i++) {

arr[i]=i+1;

}

Systemoutprintln("\n原序:"+ArraystoString(arr)+"\n");//原数组!

List<Integer> list=ArraysasList(arr);//借用集合帮忙排序!

for(Integer a:list) {

Collectionsshuffle(list);//随机排序!

Systemoutprintln("随机:"+ArraystoString(arr));//排序后!

}

}

}

//数字或者数量,你可以随意修改,二维数组也可以照用!

以上就是关于有JAVA编写程序,左手有13张牌梅花2-A,右手13张红心2-A,洗牌右手的每张压在左手的每张上，全部的内容，包括:有JAVA编写程序,左手有13张牌梅花2-A,右手13张红心2-A,洗牌右手的每张压在左手的每张上，、自学java，帮忙解释一下这个程序其中的过程，比如这三个loop在其中的作用，特别是第一个loop。、用JAVA写个代码，实现52张牌随机分给四个人等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！