How can I ensure user enters a valid choice?

Question

I'm making a simple rock paper scissors program but am unsure how to ensure that the user only enters a valid choice. I need to be able to reprompt them if they don't type some varriant of "rock", "paper", or "scissors" (capitalization doesn't matter) and later "yes" or "no". Suggestions?

import java.util.*;

public class RockPaperScissors {

private int wins = 0;
private int losses = 0;
private int ties = 0;

public static void main(String[] args) {
    // TODO Auto-generated method stub

    RockPaperScissors model = new RockPaperScissors();
    Scanner scan = new Scanner(System.in);

    while (true) {
        System.out.println("Rock, Paper, Scissors... Pick one! (Type Rock, Paper, or Scissors)");
        String playerChoice = scan.next();

        String computerChoice = model.getRandomChoice();

        System.out.println("You chose " + playerChoice + ".");
        System.out.println("The computer chose " + computerChoice + ".");

        RockPaperScissors.GameOutcome outcome = model.getGameOutcome(
                playerChoice, computerChoice);

        if (outcome == RockPaperScissors.GameOutcome.WIN) {
            System.out.println("You won! Congratulations");
        } else if (outcome == RockPaperScissors.GameOutcome.LOSE) {
            System.out.println("You lose! Better luck next time!");
        } else {
            System.out.println("Tie!");
        }

        System.out.print("Do you want to play again? (Yes/No):");

        String answer = scan.next();
        if (answer.equalsIgnoreCase("no")) {
            break;
        }
    }

    System.out.println("Thanks for playing!");
    System.out.println("Wins: " + model.getWins());
    System.out.println("Losses: " + model.getLosses());
    System.out.println("Ties: " + model.getTies());
    scan.close();
}

public static enum GameOutcome {
    WIN, LOSE, TIE;
}

public GameOutcome getGameOutcome(String userChoice, String computerChoice) {

    if (userChoice.equalsIgnoreCase("Rock")) {

        if (computerChoice.equalsIgnoreCase("Paper")) {
            losses++;
            return GameOutcome.LOSE;
        } else if (computerChoice.equalsIgnoreCase("Scissors")) {
            wins++;
            return GameOutcome.WIN;
        }
    } else if (userChoice.equalsIgnoreCase("Paper")) {

        if (computerChoice.equalsIgnoreCase("Scissors")) {
            losses++;
            return GameOutcome.LOSE;
        } else if (computerChoice.equalsIgnoreCase("Rock")) {
            wins++;
            return GameOutcome.WIN;
        }
    } else if (userChoice.equalsIgnoreCase("Scissors")) {
        if (computerChoice.equalsIgnoreCase("Rock")) {
            losses++;
            return GameOutcome.LOSE;
        } else if (computerChoice.equalsIgnoreCase("Paper")) {
            wins++;
            return GameOutcome.WIN;
        }
    }
    ties++;
    return GameOutcome.TIE;
}

public String getRandomChoice() {
    double d = Math.random();

    if (d < .33) {
        return "Rock";
    } else if (d < .66) {
        return "Paper";
    } else {
        return "Scissors";

    }
}

public int getWins() {
    return wins;
}

public int getLosses() {
    return losses;
}

public int getTies() {
    return ties;
}

}

Create a loop that continuously grabs user input until he/she enters something valid. Once the user has entered a correct answer, leave the loop — Vince, Apr 19 '15 at 23:53
@VinceEmigh how can I make this work regardless of capitalization, though? — Ryan Dorman, Apr 19 '15 at 23:54
Use `equalsIgnoreCase(String)` when comparing user input to the valid choices — Vince, Apr 19 '15 at 23:55

Jean-François Savard · Answer 1 · 2016-04-12T16:42:27.390

5

Keep the valid choices in a list, loop asking the input from the user until he enter something valid.

List<String> validChoices = Arrays.asList("rock", "paper", "scissors");
Scanner sc = new Scanner(System.in);
String choice = null;
do
{
    System.out.println("Enter a choice (rock|paper|scissors)");
    choice = sc.next().toLowerCase();//Retrieve as lower case
}
while(!validChoices.contains(choice));

edited Apr 12 '16 at 16:42

answered Apr 19 '15 at 23:54

Jean-François Savard

20,626
7
49
76

`toLowerCase()` creates a new `String` object. Probably best just to compare using `equalsIgnoreCase` – Vince Apr 20 '15 at 00:03
@VinceEmigh `equalsIgnoreCase` use `regionMatches` which call `toUpperCase`. – Jean-François Savard Apr 20 '15 at 00:06
@VinceEmigh Note that I still prefer `equalsIgnoreCase` as it have some optimization such as checking the length, and comparing by ref for character literal. However, In my example I dont even use `equals` but instead check if the list contains the string. – Jean-François Savard Apr 20 '15 at 00:08
@avgvstvs Why not always take the better way ? ;) – Jean-François Savard Apr 20 '15 at 00:55

score 3 · Accepted Answer · edited May 23 '17 at 12:31

If I were to play a session of roshambo against the computer, I'd like to be able to make my selection by only typing in the first letter of "Rock" , "Paper" or "Scissors".

Using a rich enum is a natural choice here:

private enum Choice {

    ROCK ("Rock"),
    PAPER ("Paper"),
    SCISSORS ("Scissors");

    private String displayName;

    private static final List<Choice> VALUES =
            Collections.unmodifiableList(Arrays.asList(values()));
          private static final int SIZE = VALUES.size();
    private static final Random RANDOM = new Random();        

    private Choice(String dn) {
        displayName = dn;
    }

    /**
     * Returns a random Choice.
     */
    public static Choice getRandomChoice() {
        return VALUES.get(RANDOM.nextInt(SIZE));
    }

    /**
     * Returns a Choice that matches the input string. The input is considered a match if it starts with the same character 
     * as the displayname of a Choice. If no match is found, returns null.
     */
    public static Choice fromInput(String input) {

        if (input == null || input.length() == 0) {
            return null;
        }

        for (Choice c : VALUES) {
            if (Character.toLowerCase(c.displayName.charAt(0))
                    == Character.toLowerCase(input.charAt(0))) {
                return c;
            }
        }
        return null;
    }

    /**
     * Returns the text to display to the user, asking for input to #fromInput().
     */
    public static String promptText() {
        StringBuilder sb = new StringBuilder();
        for (Choice c : VALUES) {
            if (sb.length() > 0) {
                sb.append(", ");
            }
            sb.append(c.displayName).append(" (")
                    .append(c.displayName.charAt(0)).append(")");
        }
        sb.append(". Pick one!");
        return sb.toString();
    }
}

Having most of the functionality coded declaratively in the enum, your client code will become much simpler. The enum also handles the computer's random selection (idea from this answer).

 while (true) {

        Choice choice = null;

        while (choice == null) {
            System.out.println(Choice.promptText());
            choice = Choice.fromInput(scan.next());
        }

        String computerChoice = Choice.getRandomChoice().displayName;
 // ...

You could also encapsulate most (if not all) of the logic you have in the getGameOutcome method, into Choice.

score 1 · Answer 3 · answered Apr 20 '15 at 00:09

Somesing like

if (!playerChoise.equalsIgnoreCase("paper") && ...) continue;

Or you can store valid choises in list as shown above, and use foreach loop. But it will be more difficult, becouse you need to check all variants. Maybe something like.

private boolean checkValid(String userChoise, String... variants) {
    for (String s : variants) {
        if (playerChoise.equalsIgnoreCase(s)) return true;
    }
    return false;
}

And call it for both cases:

if (!checkValid(userChoise, "rock", "papper", "scissors")) continue;

How can I ensure user enters a valid choice?

3 Answers3