扑克牌的嵌套结构体与相关的基础发牌杂谈

通过swift的结构体、枚举类型、与相关函数来实现一个21点模拟实例，要在一个类型中嵌套另一个类型，将嵌套类型的定义写在其外部类型的 {} 内，而且可以根据需要定义多级嵌套。话不多说直接上代码～

建立一个结构体作为整个21点扑克牌的主体

struct BlackjackCard {

    // 嵌套的 Suit 枚举
    // 定义相应的花色类型
    enum Suit: Character {
        case spades = "♠", hearts = "♡", diamonds = "♢", clubs = "♣"
    }

    // 嵌套的 Rank 枚举
    enum Rank: Int {
    	// 扑克牌的数字枚举(花色的符号)
        case two = 2, three, four, five, six, seven, eight, nine, ten
        // 四大角色牌
        case jack, queen, king, ace
        // 定义一个内部参数类型
        struct Values {
            let first: Int, second: Int?
        }
        // 对牌的各类花色数值进行判断预处理
        // 扑克牌从 Ace~10，以及 J、Q、K，这 13 种牌，并用一个 Int 类型的原始值表示牌的面值。
        var values: Values {
            switch self {
            // 结构体 Values 中定义了两个属性，用于反映只有 Ace 有两个数值，其余牌都只有一个数值
            case .ace:
                return Values(first: 1, second: 11)
            case .jack, .queen, .king:
                return Values(first: 10, second: nil)
            default:
                return Values(first: self.rawValue, second: nil)
            }
        }
    }

    // BlackjackCard 的属性和方法
    let rank: Rank, suit: Suit
    var description: String {
        var output = "suit is \(suit.rawValue),"
        output += " value is \(rank.values.first)"
        if let second = rank.values.second {
            output += " or \(second)"
        }
        return output
    }
}

Rank 还定义了一个计算型属性 values，它将会返回一个 Values 结构体的实例。这个计算型属性会根据牌的面值，用适当的数值去初始化 Values 实例。对于 J、Q、K、Ace 这四种牌，会使用特殊数值。对于数字面值的牌，使用枚举实例的 Int 类型的原始值。
BlackjackCard 结构体拥有两个属性——rank 与 suit。它也同样定义了一个计算型属性 description，description 属性用 rank 和 suit 中的内容来构建对扑克牌名字和数值的描述。该属性使用可选绑定来检查可选类型 second 是否有值，若有值，则在原有的描述中增加对 second 的描述。

因为 BlackjackCard 是一个没有自定义构造器的结构体，在 结构体的逐一成员构造器 中可知，结构体有默认的成员构造器，所以可以用默认的构造器去初始化新常量 theAceOfSpades：

// 开始构造结构体
let theAceOfSpades = BlackjackCard(rank: .ace, suit: .spades)
// 打印输出结果
print("theAceOfSpades: \(theAceOfSpades.description)")

尽管 Rank 和 Suit 嵌套在 BlackjackCard 中，但它们的类型仍可从上下文中推断出来，所以在初始化实例时能够单独通过成员名称（.ace 和 .spades）引用枚举实例。在上面的例子中，description 属性正确地反映了黑桃 A 牌具有 1 和 11 两个值。

在外部引用嵌套类型时，在嵌套类型的类型名前加上其外部类型的类型名作为前缀：

let heartsSymbol = BlackjackCard.Suit.hearts.rawValue

接下来谈一谈一种模拟的扑克牌发牌理牌在Java中的技术实现

// 首先要建立相应的容器添加相应的花色
List<String> pokes = new ArrayList<>();
List<String> colors = new ArrayList<>();
List<String> numbers = new ArrayList<>();
// ArrayList在于内存上来说相较于性能在这里会更优
colors.add("♥");
colors.add("♦");
colors.add("♠");
colors.add("♣");
number.add("A");
for (int i=2;i<11;i++){
	number.add(String.valueOf(i));
}
number.add("jack");
number.add("queen");
number.add("king");

将这些牌洗入牌池中

for(String c:colors){
	for (String i:number){
		String card=c+i;
		pokes.add(card);
	}
}
pokes.add("Joker");
pokes.add("JokerS");

洗牌

Collections.shuffle(pokes);

发牌

ArrayList<String> u1 = new ArrayList<>();
ArrayList<String> u2 = new ArrayList<>();
ArrayList<String> u3 = new ArrayList<>();
ArrayList<String> font = new ArrayList<>();
for (int i = 0; i < pokes.size(); i++) {
	String card = pokes.get(i);
	if (i >= 51) {
		font.add(card);
	} else if (i % 3 == 0) {
		u1.add(card);
	} else if (i % 3 == 1) {
		u2.add(card);
	} else {
		u3.add(card);
	}
}
System.out.println(font);
System.out.println(u1);
System.out.println(u2);
System.out.println(u3);

理牌

Comparator sortPK =new Comparator() {
	final String numorder = “3,4,5,6,7,8,9,10,jack,queen,King,A,2,J,S”;
	public int compare(String o1, String o2) {
	o1=o1.replaceAll("[^a-zA-z0-9JS]","");
	o2=o2.replaceAll("[^a-zA-z0-9JS]","");
	int i1=numorder.indexOf(o1);
	int i2=numorder.indexOf(o2);
	return i1-i2;
}
font.sort(sortPK);
u1.sort(sortPK);
u2.sort(sortPK);
u3.sort(sortPK);
System.out.println(font);
System.out.println(u1);
System.out.println(u2);
System.out.println(u3);