Java：在链表上使用数组

我对Java比较陌生。我是第二学期的学生

以下是我的最后一项任务，我已经介绍过了。一切都很好，我必须完成的任务已经完全完成了

这学期的任务是做一个小游戏（我的选择是猜数字游戏），而这些任务只是建立在彼此的基础上。（例如，使用至少5个函数，至少3个类，展示所有四个OOP示例，制作一个计算机播放器） 话虽如此，我的意思不是让人们去解决这些任务，因为你们会看到他们已经完成了

还有一件事给我带来麻烦。 我使用一个链表来存储猜测的数字，并在需要时调用它们。 最后，我的问题是： 如何切换带有数组的链表

代码如下：

下面是Run类：

package fourfive;
public class Run {
/*
The Game Initializing class!
>>>> "game.getNumPlayers()" //can be uncommented if you want to play
if left commented, you can watch the bots fight to the death.
------------------------------------------------------
game.setBotPlayers //Same as getNumPlayers - defines how many (Bot) players you want to add
------------------------------------------------------
 game.setTopNum() // defines the maximum range of numbers
 which you want to guess. Starting from 0!
 -----------------------------------------------------
*/
public static void main(String[] args){
    Game game = new Game(0);
    //game.getNumPlayers();
    game.setBotPlayers(100);
    game.setTopNum(2000);
    game.start();
 }
}

游戏类别：

package fourfive;

import java.util.Random;
import java.util.Scanner;

public class Game {
/*
Some Variables being defined here.
 */
private static Scanner input = new Scanner(System.in);
private int MAX_Tries;
private int TOP_Num;
private int numPlayers;
private int numBots;
private boolean gameWinner = false;
private Random rand = new Random();
private int num;
private Participants[] players; //inheritance 1
private Participants currentPlayer; //polymorphism 1

public Game(int numPlayers) {
    this(numPlayers, 10);
}

public Game(int numPlayers, int maxTries) {
    this(numPlayers, maxTries, 1000);
}

public Game(int numPlayers, int maxTries, int topNum) {
    MAX_Tries = maxTries;
    TOP_Num = topNum;
    this.numPlayers = numPlayers;
    resetPlayers();
    resetTheNumber();
}

/*
Inheritance Example 1
The following is a piece of inheritance. Whereas an array of Players whenever of the type
"Participants". Which is then resolved into the type "Human" and that is being inherited from
"Participants". And whenever Bots or Human players are joined, they will be joined within
the same array
 */
public void resetPlayers() {
    players = new Human[numPlayers + numBots];
    for (int i = 0; i < numPlayers; i++) {
        players[i] = new Human(i + 1);
    }
    for (int i = numPlayers; i < (numBots + numPlayers); i++) {
        players[i] = new Computer(i + 1, TOP_Num);
    }
}

public void setNumPlayers(int numPlayers) {
    this.numPlayers = numBots;
    resetPlayers();
}

public void setBotPlayers(int numBots) {
    this.numBots = numBots;
    resetPlayers();
}

public int getMaxTries() {
    return MAX_Tries;
}

public void setMaxTries(int maxTries) {
    this.MAX_Tries = maxTries;
}

public int getTopNum() {
    return TOP_Num;
}

public void setTopNum(int topNum) {
    this.TOP_Num = topNum;
    resetTheNumber();
    resetPlayers();
}

private void resetTheNumber() {
    num = rand.nextInt(TOP_Num);
}

public void start() {
    resetPlayers();
    System.out.println("Welcome to the Guess a Number Game!\n");
    System.out.println("Guess a number between 0 and " + (TOP_Num - 1) + "!");
    currentPlayer = players[0];
    System.out.println("The num " + num);
    /*
    Polymorphism example.
    Any object that can pore than one IS-A test is considered to be Polymorphic.
    In this case we are setting up a condition in which any given player has
    the ability to win, which is depicted from the "isCorrect()" Method.
     */
    while (!gameWinner && currentPlayer.getNumTries() < MAX_Tries) {
        for (int i = 0; i < players.length; i++) {
            //currentPlayer = players[i];
            players[i].guess();
            if (isCorrect()) {
                gameWinner = true;
                printWinner();
                break;
            } else
                printWrong();
        }
        if (!gameWinner) {
            printTriesLeft();
        }
    }
    if (!gameWinner)
        printLoser();
}

public boolean isCorrect() {
    return currentPlayer.getLastGuess() == num;
}

public void printWinner() {
    if (currentPlayer instanceof Computer)
        System.out.println("Sorry! The Bot " + currentPlayer.getPlayerNum() + " got the better of you, and guessed the number: [" + num + "] and won! Perhaps try again!");
    else
        System.out.println("GG Player " + currentPlayer.getPlayerNum() + "you guessed the Number [" + num + "] right in just " + currentPlayer.getNumTries() + " tries!");
}

public void printLoser() {
    System.out.println("Too Sad! You didn't guess within " + MAX_Tries + " tries! Try again!");
}

public void printWrong() {
    String word = "too high";
    if ((Integer.compare(currentPlayer.getLastGuess(), num)) == -1)
        word = "too low";
    System.out.println("Nope! " + word + "!");
}

public void printTriesLeft() {
    System.out.println(MAX_Tries - currentPlayer.getLastGuess() + " tries left!");
}

public void getNumPlayers() {
    System.out.print("Enter number of Persons playing => ");
    while (!input.hasNextInt()) {
        input.nextLine();
        System.out.println("Invalid input! It must be a number!");
        System.out.print("Enter the number of Players => ");
    }
    numPlayers = input.nextInt();
    System.out.print("Enter number of Bots! =>");
    while (!input.hasNextInt()) {
        input.nextLine();
        System.out.println("Invalid input! It must be a number!");
        System.out.print("Enter number of Bots! =>");
    }
    numBots = input.nextInt();
    resetPlayers();
}
}

---

您可以使用固定大小初始化数组，例如

4

，并根据需要调整大小。为此，需要一个额外的属性来存储数组的填充级别

int[] guesses = new int[4];
int guessFilling = 0;
[...]
@Override
public void guess() {
    int guess = rand.nextInt(maxGuess);
    System.out.println("Bot " + playerNum + " turn *" + guess + "*");
    if (guessFilling == guesses.length) {
        resizeGuesses();
    }
    guesses[guessFilling++] = guess;
}

private void resizeGuesses() {
    int[] newGuesses = new int[guesses.length > 0 ? 2 * guesses.length : 1];
    System.arraycopy(guesses, 0, newGuesses, 0, guesses.length);
    guesses = newGuesses;
}

---

你为什么要那样做？如果你需要一个列表，你应该使用一个列表。数组是固定长度的，因此如果需要添加元素，则需要预先分配更大的数组，并跟踪最后一个元素的位置。这实际上会导致重新实现

java.util.ArrayList

。我试图向我的教授解释这一点，因为其中的一个功能是添加任意多的玩家，但他说这“太复杂了”。所以他想让我用数组。但我想我可以把玩家限制在2到3人，也就是说，我想是2个人或者是人对电脑。太棒了。我刚才也在想类似的事情。也就是说，我必须根据阵型大小限制玩家。好的，我可以做到这一点，没有问题。但是我不确定我需要在

public int getNumTries（）{return guesses.size（）；}

@Sipko中返回什么，这将是数组的大小。但您的尝试次数可能少于数组中的字段。对于这一点，你有一个属性

guessFilling

。我觉得我在这里遗漏了一些明显的东西。我仍然无法让它正常工作。

public int getNumTries（）{return gustisfilling；}

package fourfive;
import java.util.LinkedList;
import java.util.Scanner;
public class Human extends Participants {
protected static Scanner input = new Scanner(System.in);
public Human(int playerNum) {
    numTries = 0;
    this.playerNum = playerNum;
    guesses = new LinkedList<Integer>();
}
public void guess(){
    System.out.print("Player " + playerNum + "guess =>");
    while(!input.hasNextInt()){
        input.nextLine();
        System.out.println("Invalid input!");
        System.out.print("Player " + playerNum + "guess =>");
    }
    guesses.push(input.nextInt());
}
}

package fourfive;
import java.util.Random;

public class Computer extends Human {
protected static Random rand = new Random();
protected int maxGuess;

Computer(int playerNum) {
    super(playerNum);
    maxGuess = 1000;
}
Computer(int playerNum, int topNum){
    super(playerNum);
    maxGuess = topNum;
}

@Override
public void guess() {
    int guess = rand.nextInt(maxGuess);
    System.out.println("Bot " + playerNum + " turn *" + guess + "*");
    guesses.push(guess);
}

public int getMaxGuess() {
    return maxGuess;
}

public void setMaxGuess(int num) {
    maxGuess = num;
}

}

int[] guesses = new int[4];
int guessFilling = 0;
[...]
@Override
public void guess() {
    int guess = rand.nextInt(maxGuess);
    System.out.println("Bot " + playerNum + " turn *" + guess + "*");
    if (guessFilling == guesses.length) {
        resizeGuesses();
    }
    guesses[guessFilling++] = guess;
}

private void resizeGuesses() {
    int[] newGuesses = new int[guesses.length > 0 ? 2 * guesses.length : 1];
    System.arraycopy(guesses, 0, newGuesses, 0, guesses.length);
    guesses = newGuesses;
}