2021-08-13

心里话：多特一定要往远了走啊！！

临近欧冠分组抽签，小白我脑子一热便编写了这样简单的一个分组预测程序。如果有更加进阶的功能或更加精妙的改进，希望大神们可以在评论区进行讨论，本小白也会向大家学习，一起进步！

设计思路

利用List填充栈，再利用栈的pop方法进行抽签。

1. 每一档球队的填充 ：用java.util.ArrayList<>来包装由List.of方法得到的不可变的列表；
2. 打乱每一档球队 ：直接调用Collections.shuffle方法；
3. 填充栈：用for循环遍历列表，再调用栈的push方法填充 ；
4. 分组：在循环中，从每档推出一个球队组合成一个小组；

RandomDrawTest类

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author Maximilian_Li
 */
public class RandomDrawTest {
    public static void main(String[] args) {

        List<String> first = new java.util.ArrayList<>(List.of("切尔西", "曼城", "比利亚雷亚尔", "里尔", "拜仁", "国米", "马竞", "葡萄牙体育"));
        List<String> second = new java.util.ArrayList<>(List.of("皇马", "巴萨", "尤文", "巴黎", "曼联", "利物浦", "塞维利亚", "多特蒙德"));
        List<String> third = new java.util.ArrayList<>(List.of("波尔图", "阿贾克斯", "莱比锡", "亚特兰大", "泽尼特", "本菲卡", "萨尔茨堡红牛", "顿涅茨克矿工"));
        List<String> fourth = new java.util.ArrayList<>(List.of("米兰", "沃尔夫斯堡", "布鲁日", "基辅迪那摩", "贝西克塔斯", "伯尔尼年轻人", "马尔默", "蒂拉斯波尔警长"));

        Collections.shuffle(fourth);
        Collections.shuffle(first);
        Collections.shuffle(second);
        Collections.shuffle(third);

        TeamStack<String> rankFirst = new TeamStack<>(8);
        TeamStack<String> rankSecond = new TeamStack<>(8);
        TeamStack<String> rankThird = new TeamStack<>(8);
        TeamStack<String> rankFourth = new TeamStack<>(8);

        for (String str : first) {
            rankFirst.push(str);
        }

        for (String str : second) {
            rankSecond.push(str);
        }

        for (String str : third) {
            rankThird.push(str);
        }

        for (String str : fourth) {
            rankFourth.push(str);
        }

        ArrayList<String> aGroup = new ArrayList<>();

        for (int i = 0; i < first.size(); i++) {
            aGroup.add(rankFirst.pop());
            aGroup.add(rankSecond.pop());
            aGroup.add(rankThird.pop());
            aGroup.add(rankFourth.pop());

            System.out.println(aGroup);

            aGroup.clear();

            System.out.println();
        }
    }
}

TeamStack类

import java.io.Serial;
import java.io.Serializable;
import java.util.Stack;

/**
 * @author Maximilian_Li
 */
public class TeamStack<T> extends Stack<T> implements Serializable {
    @Serial
    private static final long serialVersionUID = -2534534623465725467L;

    // 栈顶指针
    private int topPtr = -1;

	// 栈的大小
    private int size;

	// 默认容量
    private final int defaultCapacity = 10;

    private T[] arrayStack;

    public TeamStack() {
        this.arrayStack = (T[]) new Object[this.defaultCapacity];
    }

    public TeamStack(int nums) {
        this.arrayStack = (T[]) new Object[size];
    }

    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return this.topPtr == -1;
    }

    @Override
    public void ensureCapacity(int targetCapacity) {
    	// 如果目标容量小于当前大小，退出方法
        if (targetCapacity < this.size) {
            return;
        }
        
        T[] temp = arrayStack;
        arrayStack = (T[]) new Object[targetCapacity];

        if (this.size > 0) {
            System.arraycopy(temp, 0, arrayStack, 0, this.size);
        }
    }

    @Override
    public T push(T t) {
        if (arrayStack.length == this.size) {
            ensureCapacity(2 * this.size + 1);
        }

        arrayStack[++topPtr] = t;
        size++;
        return t;
    }

    @Override
    public T peek() {
        if (isEmpty()) {
            System.out.println("[peek]这个栈为空");
        }

        return arrayStack[topPtr];
    }

    @Override
    public T pop() {
        if (isEmpty()) {
            System.out.println("[pop]这个栈为空");
        }
        
        T str = arrayStack[topPtr];
        size--;
        topPtr--;
        
        return str;
    }
}