JavaFX 座位安排应用程序选择尚未被占用的随机座位？

Question

我正在创建一个 JavaFX 座位安排应用程序

@FXML
void addStudentClicked(ActionEvent event) {

    String str = studentname.getText();
    Random random = new Random();
    int randomInt = random.nextInt(9);
    if(randomInt == 0){
        if(str.isEmpty()){
          errorLabel.setText("ERROR");
        }
        else{
        studentname1.setText(studentname.getText());
        student1.setFill(studentcolour.getValue());
        }

    }
    else if(randomInt == 1){
        if(str.isEmpty()){
            errorLabel.setText("ERROR");
        }

到目前为止，这是我的代码，它将接受用户输入并将其应用于随机座位，它继续使用 else if 对于每个座位是否有一种更清洁的方式让我这样做，然后使用所有 else if 以及如何我检查一下座位是否已经被填满，所以我不会两次填满同一个座位？

还有没有办法检查颜色是否已经被取了？

Answer 1

这是一个类似（故意不一样）的例子，只是使用了控制台。

我留给你创建一个 GUI。

提示

1. 编写 GUI 与编写控制台应用程序不同，因为 GUI 是事件驱动的，因此您需要摆脱一些循环并对事件采取行动。
2. 您可以使用 ObservableLists 将列表更改反映在 UI 中。
3. 当您从 ObservableList 中删除某些内容时，它将不再在列表中，因此如果它绑定到 UI 中的某些内容，它将不再存在
   • 例如如果它是一个颜色选择列表，并且从中删除了一种颜色，则该颜色将不再可供选择。

随机播放列表，然后从随机播放的列表中挑选

这与将一副纸牌物理洗牌，然后从上到下依次抓取纸牌的想法相同。

基本思想是解决这个问题的一种方法是应用：

• Random shuffling of an array

你也可以学习：

• Unique (non-repeating) random numbers in O(1)?
• https://en.wikipedia.org/wiki/Fisher–Yates_shuffle

但是你不需要自己写shuffle算法，你可以使用java集合库中已经实现的那个。

Collections.shuffle(seatNumbers);

示例应用

基于控制台应用的示例。

我确信该示例使用了一些您不熟悉的概念，如果您使用它们，您应该理解它们或以不同的方式使用它们。特别是：

• 可以从预定义的数组（如名称）中选择颜色，而不是使用插值生成器。
• 可以使用添加到列表的循环而不是添加到 lambda 中的集合的流来生成座位号数组。

尝试运行示例应用程序并查看输出以了解它做了什么，然后尝试考虑如何将类似的概念应用到您的程序中。

import javafx.scene.paint.Color;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class MusicalDragons {

    public static final int NUM_ROUNDS = 3;

    public static void main(String[] args) {
        MusicalDragons game = new MusicalDragons();

        for (int i = 0; i < NUM_ROUNDS; i++) {
            System.out.println("Round " + (i+1));
            System.out.println("=========");
            game.play();
            System.out.println();
        }
    }

    private final List<String> dragons;
    private final List<Color> palette;
    private final List<Integer> seatNumbers;

    private final int numSeats;

    public MusicalDragons() {
        // generate a list of names.
        dragons = Arrays.asList(
                "Oyositatu (Old + Dragon)",
                "Tamasipionosi (Soul + Master)",
                "Timatamï (Crossroad + Snake)",
                "Tômiarôzi (Wealth + Master)",
                "Ararepemi (Hail + Snake)",
                "Umasumera (Horse + Emperor)",
                "Umitatu (Sea + Dragon)",
                "Akitatu (Autumn + Dragon)",
                "Tawayatatu (Weak + Dragon)",
                "Amoritatu (Descend From Heaven + Dragon)"
        );

        numSeats = dragons.size() - 1;

        // generate a list of colors.
        palette = new ArrayList<>();
        for (int i = 0; i < numSeats; i++) {
            palette.add(
                    Color.RED.interpolate(
                            Color.VIOLET, 
                            i * (1.0 / (numSeats - 1))
                    )
            );
        }

        // generate a list of seat numbers.
        seatNumbers =
                IntStream.range(0, numSeats)
                        .boxed()
                        .collect(
                                Collectors.toCollection(
                                        ArrayList::new
                                )
                        );
    }

    private void play() {
        // randomize the order of everything.
        Collections.shuffle(palette);
        Collections.shuffle(seatNumbers);
        Collections.shuffle(dragons);

        // display the seat assignments.
        for (int i = 0; i < numSeats; i++) {
            System.out.println(
                    dragons.get(i) + "\n" +
                            "  gets seat #" + seatNumbers.get(i) + "\n" +
                            "  colored " + palette.get(i)
            );
        }

        // hmm, one dragon missed out . . .
        System.out.println();
        System.out.println(
                dragons.get(numSeats) + 
                        " does not get a seat and is very angry."
        );
    }
}

输出

Round 1
=========
Tawayatatu (Weak + Dragon)
  gets seat #1
  colored 0xf64884ff
Tamasipionosi (Soul + Master)
  gets seat #4
  colored 0xff0000ff
Oyositatu (Old + Dragon)
  gets seat #7
  colored 0xfd0e1aff
Ararepemi (Hail + Snake)
  gets seat #0
  colored 0xf074d4ff
Umasumera (Horse + Emperor)
  gets seat #8
  colored 0xfb1d35ff
Amoritatu (Descend From Heaven + Dragon)
  gets seat #3
  colored 0xf73a6aff
Timatamï (Crossroad + Snake)
  gets seat #2
  colored 0xf4579fff
Umitatu (Sea + Dragon)
  gets seat #5
  colored 0xf265b9ff
Tômiarôzi (Wealth + Master)
  gets seat #6
  colored 0xf92b4fff

Akitatu (Autumn + Dragon) does not get a seat and is very angry.

Answer 2

使用随机函数的一个有趣的替代方法是将所有选择放入List，然后应用Collection 方法shuffle()。然后，您可以遍历列表。这样可以确保每个选项只选择一次。

我没有仔细查看代码，无法判断 switch/case 构造是否是更好的选择，但这始终是需要考虑的问题。