如果用户输入已经在java中的数组中，如何在以后检查时将其保存在数组中？

我必须做一个随机数字猜测游戏，每一轮我只能猜测10次。我感到困惑的是，我需要检查在那一轮中是否有任何猜测被重复。我知道我必须制作一个数组并将数字存储在其中，但我不知道如何做到这一点

这是我的全部代码，其他一切都按预期工作：

import java.util.Scanner;
import java.util.Random;
public class GuessingGame {

 private static final int MIN_NUMBER = 1;
 private static final int MAX_NUMBER = 205;
 private static final int QUIT_VALUE = -1;
 private static final int LOSE_VALUE = -2;
 private static final int MAX_GAMES = 2;
 private static final int MAX_GUESSES = 10;
 private static final int HINT_THRESHOLD = 5;
 private static final int BACKDOOR_VALUE = -314;

 private static final String NOPE_MSG = "nope...";
 private static final String NOPE_NOPE_MSG =
  "you've already guessed that wrong guess...";
 private static final String INVALID_INPUT_BEGIN =
  "*** invalid input -- ";
 private static final String INVALID_INPUT_LESS_MIN_MSG =
  INVALID_INPUT_BEGIN + "must be greater than " + (MIN_NUMBER - 1);
 private static final String INVALID_INPUT_GREATER_MAX_MSG =
  INVALID_INPUT_BEGIN + "must be less than " + (MAX_NUMBER + 1);
 private static final String INVALID_INPUT_YN_MSG =
  INVALID_INPUT_BEGIN + "must be n or y";
 private static final String WINNER_MSG =
  "you're a winner... # of guesses: ";
 private static final String LOSER_MSG =
  "too many guesses entered... the number was ";
 private static final String QUITTER_MSG =
  "you're a quitter... the number was ";
 private static final String MAX_GAMES_PLAYED_MSG =
  "you've played the maximum number (" + MAX_GAMES + ") of games";
 private static final String ENTER_GUESS_PROMPT =
  "enter a guess between " + MIN_NUMBER + " and " + MAX_NUMBER +
  " (" + QUIT_VALUE + " to quit): ";
 private static final String PLAY_AGAIN_PROMPT =
  "Do you want to play again (n or y)? ";

 private static final String BOLD_BEGIN = "*** ";
 private static final String BOLD_END = " ***";
 private static final String PLAY_MSG = " playing the CSC" + MAX_NUMBER +
  " guessing game." + BOLD_END;
 private static final String WELCOME_MSG =
  BOLD_BEGIN + "Hello! Have fun" + PLAY_MSG;
 private static final String THANKS_MSG =
  BOLD_BEGIN + "Thanks for" + PLAY_MSG;

 static Random rng = new Random(System.currentTimeMillis());
 static Scanner stdin = new Scanner(System.in);
 static Scanner scan = new Scanner(System.in);

 static int guess;
 static int numberOfGames = 0;
 static int numberOfWins = 0;
 static int numberOfLoses = 0;
 static boolean endStart = true; // Check if this boolean is used

 public static void main(String[] args) {

  PlayGame();
  PostGame();
  EndGame();
 }

 public static void PlayGame() {

  int guessCounter = 0;
  int n = MIN_NUMBER + rng.nextInt(MAX_NUMBER);

  System.out.println(WELCOME_MSG);
  boolean test = true;
  do {

   System.out.println();
   System.out.print(ENTER_GUESS_PROMPT);
   guess = stdin.nextInt();
   guessCounter = guessCounter + 1;

   if (guess < MIN_NUMBER && guess != BACKDOOR_VALUE &&
    guess != QUIT_VALUE) {
    System.out.println(INVALID_INPUT_LESS_MIN_MSG + "\n");
   }

   if (guess > MAX_NUMBER) {
    System.out.println(INVALID_INPUT_GREATER_MAX_MSG + "\n");
   }

   // Giving the user the answer 
   if (guess == BACKDOOR_VALUE) {
    System.out.println(n);
   }

   // Quiting the round and giving the chance to end the game
   if (guess == QUIT_VALUE) {
    System.out.println((QUITTER_MSG + n) + "\n" +
     PLAY_AGAIN_PROMPT);
    numberOfLoses++;
    String val = scan.next();
    if (val.equalsIgnoreCase("y")) {
     numberOfGames++;
     PlayGame();
    }

    if (val.equalsIgnoreCase("n")) {
     System.out.println(THANKS_MSG);
     test = false;
     PostGame();
     break;
    }


   }

   // Correct guess on the last try
   if (guessCounter == MAX_GUESSES || guess == n) {
    numberOfGames++;
    System.out.println(WINNER_MSG + guessCounter);
    numberOfWins++;
    System.out.println(PLAY_AGAIN_PROMPT);
    String val = scan.next();
    if (val.equalsIgnoreCase("y"))
     PlayGame();
    if (val.equalsIgnoreCase("n")) {
     System.out.println(THANKS_MSG);
     test = false;
     PostGame();
     break;
    }
   }

   // Max games
   if (numberOfGames == MAX_GAMES) {
    System.out.println(MAX_GAMES_PLAYED_MSG);
    test = false;
    PostGame();
    break;
   }

   // Max guesses
   if (guessCounter == MAX_GUESSES) {
    numberOfGames++;
    System.out.println(LOSER_MSG + n + "\n" + PLAY_AGAIN_PROMPT);
    numberOfLoses++;
    String val = scan.next();
    if (val.equalsIgnoreCase("y"))
     PlayGame();
    if (val.equalsIgnoreCase("n")) {
     System.out.println(THANKS_MSG);
     test = false;
     PostGame();
     break;
    }
   }

   // Guessing in the range of the bonds
   if (guess > MIN_NUMBER || guess < MAX_NUMBER) {
    if (guess != n) {
     System.out.print(NOPE_MSG);
    }
    if (guess == n) {
     numberOfGames++;
     System.out.println(WINNER_MSG + guessCounter);
     numberOfWins++;
     System.out.println(PLAY_AGAIN_PROMPT);
     String val = scan.next();
     if (val.equalsIgnoreCase("y"))
      PlayGame();
     if (val.equalsIgnoreCase("n")) {
      System.out.println(THANKS_MSG);
      test = false;
      PostGame();
      break;
     }
    }
   }

   // Giving hints after 5 tries until the max # of guesses
   if (guessCounter == HINT_THRESHOLD ||
    guessCounter == (HINT_THRESHOLD + 1) ||
    guessCounter == (HINT_THRESHOLD + 2) ||
    guessCounter == (HINT_THRESHOLD + 3) ||
    guessCounter == (HINT_THRESHOLD + 4) ||
    guessCounter == (HINT_THRESHOLD + 5)) {
    if (guess != n && guess > n) {
     System.out.println(" lower");
    }
    if (guess != n && guess < n) {
     System.out.println(" higher");
    }
   }
  }
  while (guess > MIN_NUMBER || guess < MAX_NUMBER);
 }

 // Post game information
 public static void PostGame() {
  int winningPct = 0;
  System.out.print("Played: " + numberOfGames + ";" +
   " Won: " + numberOfWins + ";" +
   " Lost: " + numberOfLoses + ";");
  if (numberOfGames != 0) {
   System.out.println(" winningPct: " +
    (winningPct = numberOfWins / numberOfGames));
  } else {
   winningPct = 0;
  }
  EndGame();
 }

 // Ending the game
 public static void EndGame() {

 }
}

import java.util.Scanner；
导入java.util.Random；
公开课猜谜游戏{
专用静态最终整数最小值=1；
专用静态最终整数最大值=205；
私有静态最终int QUIT_值=-1；
私有静态最终int LOSE_值=-2；
私人静态最终整数最大游戏=2；
私有静态最终整数最大猜测=10；
私有静态最终int_阈值=5；
私有静态final int BACKDOOR_值=-314；
私有静态最终字符串NOPE_MSG=“NOPE…”；
私有静态最终字符串NOPE_NOPE_MSG=
“你已经猜错了……”；
私有静态最终字符串无效\u输入\u开始=
“***无效输入--”；
私有静态最终字符串无效\u INPUT\u LESS\u MIN\u MSG=
无效的_输入_BEGIN+”必须大于“+（最小值-1）；
私有静态最终字符串无效\u输入\u较大\u最大\u消息=
无效的_输入_BEGIN+”必须小于“+（最大值+1）；
私有静态最终字符串无效\u输入\u YN\u MSG=
无效的\u输入\u BEGIN+“必须是n或y”；
私有静态最终字符串获胜者\u MSG=
“你是一个赢家……”猜测：“你是一个赢家。”；
私有静态最终字符串\u MSG=
“输入的猜测太多……数字为”；
私有静态最终字符串退出程序\u MSG=
“你是一个放弃者……号码是”；
私人静态最终字符串最大\u游戏\u播放\u消息=
“您已经玩了最多的游戏（“+MAX_GAMES+”）”；
私有静态最终字符串输入\u猜测\u提示=
“输入一个介于“+MIN_NUMBER+”和“+MAX_NUMBER”之间的猜测+
（“+QUIT_VALUE+”表示退出）：”；
私有静态最终字符串播放\u再次\u提示=
“你想再玩一次（n还是y）？”；
私有静态最终字符串BOLD_BEGIN=“***”；
私有静态最终字符串BOLD_END=“***”；
私有静态最终字符串播放\u MSG=“播放CSC”+最大值+
“猜谜游戏”+加粗结束；
私有静态最终字符串WELCOME\u MSG=
BOLD_BEGIN+“你好！玩得开心”+PLAY_MSG；
私有静态最终字符串谢谢\u MSG=
粗体+开始+感谢+播放消息；
静态随机rng=新随机（System.currentTimeMillis（））；
静态扫描仪stdin=新扫描仪（System.in）；
静态扫描仪扫描=新扫描仪（System.in）；
静态整数猜测；
静态int numberOfGames=0；
静态int numberOfWins=0；
静态int numberofloss=0；
静态布尔值endStart=true；//检查是否使用此布尔值
公共静态void main（字符串[]args）{
游戏（）；
赛后（）；
结束游戏（）；
}
公共静态void游戏（）{
int猜测计数器=0；
int n=最小数量+下一个数量（最大数量）；
System.out.println（欢迎消息）；
布尔检验=真；
做{
System.out.println（）；
系统输出打印（输入猜测提示）；
guess=stdin.nextInt（）；
猜测计数器=猜测计数器+1；
如果（猜测<最小值和猜测！=后门值&&
猜！=退出（数值）{
System.out.println（无效的输入值小于最小值消息+“\n”）；
}
如果（猜测>最大值）{
System.out.println（无效的\u输入\u较大值\u最大值\u消息+“\n”）；
}
//给用户答案
如果（猜测==后门_值）{
系统输出println（n）；
}
//退出这一轮，给他们结束比赛的机会
如果（猜测==退出值）{
System.out.println（（QUITTER\u MSG+n）+“\n”+
再次播放（提示）；
numberofloss++；
字符串val=scan.next（）；
如果（val.equalsIgnoreCase（“y”））{
numberOfGames++；
游戏（）；
}
如果（val.equalsIgnoreCase（“n”））{
System.out.println（谢谢消息）；
测试=假；
赛后（）；
打破
}
}
//在最后一次尝试中更正猜测
如果（猜测计数器==MAX|u猜测|猜测==n）{
numberOfGames++；
System.out.println（WINNER\u MSG+guessCounter）；
numberOfWins++；
System.out.println（再次播放提示）；
字符串val=scan.next（）；
如果（val.equalsIgnoreCase（“y”））
游戏（）；
如果（val.equalsIgnoreCase（“n”））{
System.out.println（谢谢消息）；
测试=假；
赛后（）；
打破
}
}
//马克斯游戏
如果（numberOfGames==MAX_GAMES）{
System.out.println（MAX\u GAMES\u PLAYED\u MSG）；
测试=假；
赛后（）；
打破
}
//马克斯猜测
if（猜测计数器==最大猜测）{
numberOfGames++；
System.out.println（失败者消息+n+“\n”+再次播放提示）；
numberofloss++；
字符串val=scan.next（）；
如果（val.equalsIgnoreCase（“y”））
游戏（）；
如果（val.equalsIgnoreCase（“n”））{
System.out.println（谢谢消息）；
测试=假；
赛后（）；
打破
}
}
//对债券范围的猜测
如果（猜测>最小值| |猜测<最大值）{
如果（猜测！=n）{
系统输出打印（NOPE_MSG）；
}
如果（猜测==n）{
numberOfGames++；
System.out.println（WINNER\u MSG+guessCounter）；
numberOfWins++；
System.out.println（再次播放提示）；
字符串val=scan.next（）；
如果（val.equalsIgnoreCase（“y”））
游戏（）；
如果（val.equalsIgnoreCase（“n”））{
System.out.println（谢谢消息）；
测试=假；
赛后（）；
打破
}
}
}
//5次尝试后给出提示，直到猜到最多为止
如果（猜测计数器==提示\u阈值||
猜测计数器==（提示\u阈值+1）||
猜测计数器==（提示\u阈值+2）||
猜测计数器==（提示\u阈值+3）||
猜测计数器==（提示\u阈值+4）||
猜测计数器==（提示\u阈值+5））{
如果（猜测！=n&&guess>n）{
系统输出打印项次（“下”）；
}
if（猜测！=n&&guess最小值| |猜测<最大值）；
Set<Integer> guessedNumbers = new HashSet<Integer>();
if(guessedNumbers.contains(guess)){
    System.out.println("You already guessed this earlier");
}
else{
    guessedNumbers.add(guess);
}

Game game = new Game();
Player player = new Player();

boolean numberGuessed = false;
while (!numberGuessed) {
    int guess = player.makeGuess();
    if (game.checkGuess(guess)) {
        System.out.println("You win!");
    } else {
        System.out.println("Please, try again");
}

class Player {

    private int guessCount;

    public String grabInput() {
        System.out.println("Make a guess");
        System.out.print("> ");
        // take Scanner input, parse number or exit message
    }

    public int makeGuess() {
        //present your guess
        guessCount++;
    }
}