无情的红五发牌员

 【实验目的和要求】

1. 理解多线程技术；
2. 了解红五游戏的规则。
3. 了解敏捷开发过程

【实验内容】

实现一个红五的发牌程序，给四位玩家排序时候采用多线程的方式进行，排序结束再统一输出每一位玩家排好序的结果。

1）游戏由两副牌构成

2）4个玩家

3）系统能随机洗牌后模拟真实情况分别向4个玩家发牌，并剩下8张底牌

4）程序能符合人性的方式输出四个玩家手上的牌和底牌（按照人类合理的理牌顺序输出）*合理的理牌顺序是分花色，分大小归类排序，每次都按照打2，并且黑心是主牌进行整理主牌大小顺序：

1、黑色：红心5，大王，小王，黑桃3，梅花3，黑桃2，梅花2，红色2，方色2， A,K,Q,J,10,9,8,7,6, 5,4

2、红色副牌：A,K,Q,J,10,9,8,7,6, 4,3

3、梅花色副牌：A,K,Q,J,10,9,8,7,6,5,4 

4、方色副牌：A,K,Q,J,10,9,8,7,6,5, 4,3

结果：

玩家1的手牌：
黑桃 3
黑桃 2
方块 2
黑桃 8
黑桃 7
黑桃 6
黑桃 5
红桃 A
红桃 K
红桃 6
红桃 3
红桃 3
梅花 A
梅花 Q
梅花 10
梅花 9
梅花 9
梅花 8
梅花 4
方块 A
方块 K
方块 Q
方块 9
方块 7
方块 4

玩家2的手牌：
 小王
黑桃 3
红桃 2
红桃 2
梅花 3
梅花 2
黑桃 K
黑桃 J
黑桃 J
红桃 K
红桃 Q
红桃 10
红桃 9
红桃 4
梅花 K
梅花 6
梅花 6
梅花 5
梅花 4
方块 Q
方块 J
方块 10
方块 10
方块 6
方块 5

玩家3的手牌：
红桃 5
 大王
 小王
梅花 3
方块 2
黑桃 A
黑桃 10
黑桃 7
黑桃 4
红桃 Q
红桃 J
红桃 8
红桃 8
红桃 7
红桃 4
梅花 J
梅花 10
梅花 8
梅花 7
方块 K
方块 J
方块 8
方块 6
方块 5
方块 4

玩家4的手牌：
红桃 5
 大王
黑桃 2
梅花 2
方块 3
方块 3
黑桃 A
黑桃 K
黑桃 Q
黑桃 10
黑桃 8
黑桃 6
黑桃 5
红桃 J
红桃 10
红桃 9
红桃 7
红桃 6
梅花 K
梅花 Q
梅花 J
梅花 7
梅花 5
方块 A
方块 9

底牌：
方块 7
方块 8
梅花 A
红桃 A
黑桃 4
黑桃 9
黑桃 9
黑桃 Q

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyDealer {
	private static Lock lock = new ReentrantLock();
	private static List list1 = new ArrayList<>();
	private static List list2 = new ArrayList<>();
	private static List list3 = new ArrayList<>();
	private static List list4 = new ArrayList<>();
	private static Poker[] pokers = new Poker[108];
	private Map hs = new HashMap<>();
	private Map pt = new HashMap<>();

	public static void main(String[] args) {
		ExecutorService executor = Executors.newFixedThreadPool(4); // 四个玩家的线程池
		MyDealer dealer = new MyDealer();
		dealer.init();
		executor.submit(() -> {
			fapai(list1);
		});
		executor.submit(() -> {
			fapai(list2);
		});
		executor.submit(() -> {
			fapai(list3);
		});
		executor.submit(() -> {
			fapai(list4);
		});
		// 查看所有牌
//		for (Poker poker : pokers) {
//			System.out.println(dealer.hs.get(poker.huase) + " " + dealer.pt.get(poker.point));
//		}
		System.out.println("玩家1的手牌：");
		Collections.sort(list1, Comparator.comparing(Poker::getWeight).thenComparing(Poker::getHuase)
				.thenComparing(Poker::getOne).thenComparing(Poker::getPoint).reversed());
		for (Poker poker : list1) {
			System.out.println(dealer.hs.get(poker.huase) + " " + dealer.pt.get(poker.point));
		}
		System.out.println("\n玩家2的手牌：");
		Collections.sort(list2, Comparator.comparing(Poker::getWeight).thenComparing(Poker::getHuase)
				.thenComparing(Poker::getOne).thenComparing(Poker::getPoint).reversed());
		for (Poker poker : list2) {
			System.out.println(dealer.hs.get(poker.huase) + " " + dealer.pt.get(poker.point));
		}
		System.out.println("\n玩家3的手牌：");
		Collections.sort(list3, Comparator.comparing(Poker::getWeight).thenComparing(Poker::getHuase)
				.thenComparing(Poker::getOne).thenComparing(Poker::getPoint).reversed());
		for (Poker poker : list3) {
			System.out.println(dealer.hs.get(poker.huase) + " " + dealer.pt.get(poker.point));
		}
		System.out.println("\n玩家4的手牌：");
		Collections.sort(list4, Comparator.comparing(Poker::getWeight).thenComparing(Poker::getHuase)
				.thenComparing(Poker::getOne).thenComparing(Poker::getPoint).reversed());
		for (Poker poker : list4) {
			System.out.println(dealer.hs.get(poker.huase) + " " + dealer.pt.get(poker.point));
		}
		System.out.println("\n底牌：");
		for (Poker poker : pokers) {
			if (poker.is == 0)
				System.out.println(dealer.hs.get(poker.huase) + " " + dealer.pt.get(poker.point));
		}
	}

	public void init() {
		// 所有牌初始化
		int k = 0;
		hs.put(4, "");
		hs.put(3, "黑桃");
		hs.put(2, "红桃");
		hs.put(1, "梅花");
		hs.put(0, "方块");
		for (int i = 0; i < 4; i++) {// 花色
			for (int j = 1; j <= 13; j++) { // 点数 11:J 12:Q 13:K
				pokers[k++] = new Poker(i, j);
				pokers[k++] = new Poker(i, j);
			}
		}
		for (int i = 1; i <= 15; i++) {
			switch (i) {
			case 1:
				pt.put(i, "A");
				break;
			case 11:
				pt.put(i, "J");
				break;
			case 12:
				pt.put(i, "Q");
				break;
			case 13:
				pt.put(i, "K");
				break;
			case 14:
				pt.put(i, "小王");
				break;
			case 15:
				pt.put(i, "大王");
				break;
			default:
				pt.put(i, String.valueOf(i));
				break;
			}
		}
		Poker pokerQueen1 = new Poker(4, 14);
		Poker pokerQueen2 = new Poker(4, 14);
		pokers[104] = pokerQueen1;
		pokers[105] = pokerQueen2;
		Poker pokerKing1 = new Poker(4, 15);
		Poker pokerKing2 = new Poker(4, 15);
		pokers[106] = pokerKing1;
		pokers[107] = pokerKing2;

	}

	public static void fapai(List list) {
		Random rand = new Random();
		for (int i = 0; i < 25; i++) {
			lock.lock();
			int index = rand.nextInt(108);
			while (pokers[index].is == 1) {
				index = rand.nextInt(108);
			}
			pokers[index].is = 1;
			list.add(pokers[index]);
			lock.unlock();
		}
	}

	class Poker {
		int huase;
		int point;
		int is;
		int weight;
		int one;

		Poker(int huase, int point) {
			this.huase = huase;
			this.point = point;
			this.is = 0;
			if (huase == 2 && point == 5) {
				// 红五
				weight = 3;
			} else if (point > 13 || point == 2 || point == 3 && huase != 2) {
				// 主牌
				weight = 2;
			} else {
				// 普通牌
				weight = 1;
			}
			// Ace特殊处理，将普通牌先做Ace判断再排序
			if (point == 1) {
				one = 1;
			} else {
				one = 0;
			}
		}

		public int getPoint() {
			return point;
		}

		public int getHuase() {
			return huase;
		}

		public int getWeight() {
			return weight;
		}

		public int getOne() {
			return one;
		}
	}
}