As I stated in comments, the review by Sharon Ben Asher is great. I don't want to repeat everything already said in that review. Since Adam Lam has asked me to post code that illustrates the improvements mentioned in the review the majority of my review/answer is going to be code.

Note that the code below is not a complete implementation of all of the features of the game which this program is based on. I have included many comments within the code to help illustrate how things are working and what improvements could be made in the future. I tried to stay as close to the original presentation/view as I could.

Adam, As I mentioned in my comment on the review by Sharon Ben Asher, you should consider doing some additional research and reading. I think you could benefit from going through The Java Tutorials to learn about topics like OOP Concepts, Classes and Objects, Collections framework, and other essentials like Basic I/O. The code below uses the MVC Pattern to separate the data model from the presentation of that data and the logic of the gameplay, but there many other patterns that are useful in different situations.

With all of that said, here is the code...

This is the controller class:

package gameRefactor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

/**
 * This class is the controller of the game;
 * it coordinates the data model and view.
 */
public class WwtbamController {

    private static final Random random = new Random();
    private static final List<LifeLine> lifeLines = new ArrayList<>();
    //TODO: This is a basic example, you could have more than one view in which case you 
    // should use the Factory Pattern to determine which one to use at runtime. For example
    // perhaps someday you wish to build a GUI (Graphical User Interface) in addition to 
    // your text based interface. The practice of coding to an interface will make this easier.
    private static final View view = new WwtbamView();

    /**
     * Determines whether user input is valid based on whether the
     * input was parsed into a valid answer selection or lifeline given
     * the context of the situation.
     * @param question the currently active question; used to validate whether
     *          the user has entered a valid answer selection.
     * @param token a representation of user input as one of the answers to the question
     * @param lifeline a representation of user input as one of the lifeline options
     * @return true if the user input is valid, false otherwise.
     */
    private static boolean isInputValid(Question question, AnswerToken token, LifeLine lifeline){
        if(question.getAnswerTokens().contains(token)){
            return true;
        }

        return lifeline != null;
    }

    /**
     * Performs the logic necessary to use a lifeline
     * @param question the currently active question
     * @param lifeLine the lifeline selected for use
     */
    private static void useLifeLine(Question question, LifeLine lifeLineUsed){
        lifeLines.remove(lifeLineUsed);

        switch(lifeLineUsed){

        case CALL_A_FRIEND:
            //TODO: this is a very simple placeholder, you should replace this
            //      with whatever logic you want to use for generating your 
            //      "Call A Friend" results.
            view.displayCallFriendResults();
            break;
        case FIFTY_FIFTY:
            useFiftyFiftyLifeLine(question);
            break;
        case POLL_AUDIENCE:
            //TODO: this is a very simple placeholder, you should replace this
            //      with whatever logic you want to use for generating your 
            //      "Poll The Audience" results.
            view.displayAudienceResults();
            break;
        default: 
            System.err.println("ERROR Unknown lifeline; this should never happen!");
        }
    }

    /**
     * Executes the business logic of using the 50/50 lifeline by removing
     * 2 random incorrect answers from the specified question.
     * @param question the question whose answers are to be modified.
     */
    private static void useFiftyFiftyLifeLine(Question question){
        for(int i=0; i<2; i++){
            removeRandomIncorrectAnswer(question);
        }
    }

    /**
     * Removes a single random incorrect answer from the specified question.
     * @param question the question from which an answer will be removed.
     */
    private static void removeRandomIncorrectAnswer(Question question){
        List<Answer> incorrectAnswers = question.getIncorrectAnswers();
        int randomIndex = random.nextInt(incorrectAnswers.size());
        Answer randomAnswer = incorrectAnswers.get(randomIndex);

        question.removeAnswer(randomAnswer);
    }

    /**
     * Loads the questions into the appropriate data model
     * @return a list of all loaded questions.
     */
    private static List<Question> loadQuestions(){
        //TODO: In the game show the questions are categorized by difficulty
        //      so a List is not the most appropriate solution in the long run.
        List<Question> questions = new ArrayList<>();

        //TODO: Eventually you probably want to store question information in one or more files
        //      but for now they are hard-coded. If you do store question data in files then you will need to
        //      validate the data as well - for example if you want each question to have exactly 4 
        //      answers you will need to decide how to handle the situation where there are more or less
        //      than 4 answers specified in the data file. You could do that here in the controller class
        //      or split the responsibility between this class and the Question class.
        questions.add(new Question("What does NBA most commonly stand for?", AnswerToken.A,
                        new Answer(AnswerToken.A, "National Basketball Association"),
                        new Answer(AnswerToken.B, "New Brunswick Accounting"),
                        new Answer(AnswerToken.C,"Nevada Bowling Association"),
                        new Answer(AnswerToken.D,"Nile Boating Associates")));
        questions.add(new Question("Which country invented hockey?", AnswerToken.A,
                        new Answer(AnswerToken.A, "Iceland"),
                        new Answer(AnswerToken.B, "Canada"),
                        new Answer(AnswerToken.C, "Australia"),
                        new Answer(AnswerToken.D, "China")));
        return questions;
    }

    //TODO: As a general note someone playing the TV game show
    //      can decide to "walk away" at any time and keep the winnings
    //      that they have earned up to that point. This feature is not
    //      implemented.

    //TODO: In the game show there is the concept of a "Safety Net" 
    //      at which point the player can't leave with less than a 
    //      specific amount of money. This feature is also not yet
    //      implemented.
    public static void main(String[] args) {
        lifeLines.addAll(Arrays.asList(LifeLine.values()));     
        List<Question> questions = loadQuestions();

        view.displayIntro();

        int randomIndex = -1;

        //TODO: For now this loop simply continues until there are no more questions,
        //      but in the long run you will need to modify the logic to end when
        //      the player has successfully answered the $1M question.
        while(!questions.isEmpty()){
            randomIndex = random.nextInt(questions.size());
            //TODO: This is ok for a preliminary version of the game
            //      However, eventually you may want the user to be able to
            //      start over if they lose without having to re-run the program.
            //      In this case you don't want to modify the questions in this way,
            //      you would want to make a temporary copy of each question as you go
            //      and modify that.
            Question randQuestion = questions.get(randomIndex);
            boolean isFinalAnswer = false;

            while(!isFinalAnswer){
                view.displayQuestion(randQuestion);
                view.displayLifeLines(lifeLines);
                UserResponse questionResponse = view.getUserResponseToQuestion(lifeLines);

                //Validate input - the user should have entered an answer or lifeline
                //  If that is not the case, display an error and ask for more input
                //  until the response is valid.
                while( !isInputValid(
                        randQuestion, 
                        questionResponse.getAnswerToken(),
                        questionResponse.getLifeline())){
                    view.displayErrorMessage("Invalid Input. Please Try Again. \n\n");
                    questionResponse = view.getUserResponseToQuestion(lifeLines);
                }

                //When the user selects a lifeline use that lifeline.
                if(questionResponse.getLifeline() != null){
                    useLifeLine(randQuestion, questionResponse.getLifeline()); 
                }else{
                    //The user must have entered an answer so
                    //  ask if that's their final answer
                    isFinalAnswer = view.getIsFinalAnswer();
                    if(isFinalAnswer){
                        //If the player gave a final answer, check to see if it's correct
                        boolean rightAnswer = randQuestion.isCorrectAnswer(questionResponse.getAnswerToken());
                        if(rightAnswer){
                            //If the final answer was correct, let the player know.
                            view.displayOneLineMessage("You got it right! Congrats!");
                            //TODO: for now it is necessary to ensure that you don't ask the same question twice;
                            //      However, in the long run questions should be categorized and only one from
                            //      each category will be asked per game.
                            questions.remove(randomIndex);
                        }else{
                            //When the final answer is not correct end the game.
                            view.displayOneLineMessage("Sorry, that answer was incorrect. The game is now over. Please play again.");
                            return;
                        }
                    }
                }
            }
        }
        view.closeOpenResources();
    }

}

Here is the implementation of a View:

package gameRefactor;

import java.util.List;
import java.util.Scanner;

/**
 * This is the text-based implementation of the View interface. It obtains user
 * input from System.in and displays information by writing to System.out
 */
public class WwtbamView implements View {
    private static final Scanner scanner = new Scanner(System.in);

    public String getUserName(){
        displayOneLineMessage("What is your name?");
        return scanner.nextLine().trim();
    }

    public void displayQuestion(Question question){
        displayOneLineMessage(question.getText());
        for(Answer answer: question.getAnswers()){
            displayAnswer(answer);
        }
    }

    public void displayAnswer(Answer answer){
        StringBuilder builder = new StringBuilder();
        builder.append(answer.getToken().name());
        builder.append(". ");
        builder.append(answer.getText());
        displayOneLineMessage(builder.toString());
    }

    public void displayLifeLines(List<LifeLine> lifeLines){
        if(lifeLines.isEmpty()){
            displayOneLineMessage("You have no remaining lifelines.");
        }
        for(int i = 0; i < lifeLines.size(); i++){
            displayOneLineMessage((i+1) + ". "+lifeLines.get(i));
        }
    }

    public void displayCallFriendResults(){
        displayOneLineMessage("Your friend says C is statistically the best answer to multiple choice questions.");
    }

    public void displayAudienceResults(){
        displayOneLineMessage("The audience is no help, they didn't even vote! How rude!");
    }

    public void displayOneLineMessage(String promptText){
        System.out.println(promptText);
    }

    /**
     * Tries to obtain an AnswerToken from the user input
     * @param input the text entered by the user (assumed already trimmed)
     * @return the AnswerToken matching the input or null if there is no matching token.
     */
    private AnswerToken getAnswerTokenFromInput(String input){
        input = input.toUpperCase();
        try{
            AnswerToken token = AnswerToken.valueOf(input);
            return token;
        }catch(IllegalArgumentException e){
            return null;
        }   
    }

    /**
     * Tries to obtain a LifeLife from the user input
     * @param a list of the lifelines available when the user made their selection
     * @param input the text entered by the user (assumed already trimmed)
     * @return the LifeLine chosen by the user
     */
    private LifeLine getLifeLineFromInput(List<LifeLine> lifelines, String input){
        try{
            //Get the life line selected adjusting for the fact that the user
            //  input is 1 to 3 while the array is indexed starting at 0
            int index = Integer.parseInt(input)-1;
            if(index >= 0 && index < lifelines.size())
                return lifelines.get(index);
        }catch(NumberFormatException e){
            //Nothing to do here, user entered a non-integer value.
        }
        return null;
    }

    public UserResponse getUserResponseToQuestion(List<LifeLine> lifelines){
        String userInput = scanner.nextLine().trim();

        //Try to get an answer token from the user
        AnswerToken token = getAnswerTokenFromInput(userInput);
        //Try to get a lifeline selection from the user
        LifeLine lifeLine = getLifeLineFromInput(lifelines, userInput);

        return new UserResponse(token, lifeLine);
    }

    /**
     * Asks the user whether their answer is final
     * @return true if the user indicates the answer is final, false otherwise.
     */
    public boolean getIsFinalAnswer(){
        String finalAnswer = null;
        do{
            displayOneLineMessage("Is this your final answer? (yes or no)");
            finalAnswer = scanner.nextLine().trim();
        }while(!isValidYesNoResponse(finalAnswer));

        finalAnswer = finalAnswer.trim();
        return "Yes".equalsIgnoreCase(finalAnswer) || "Y".equalsIgnoreCase(finalAnswer);
    }

    /**
     * Validates that the specified input represents a valid yes or no response.
     * @param input the string to analyze
     * @return true if the input is yes, y, no, n (case insensitive); false otherwise.
     */
    private boolean isValidYesNoResponse(String input){
        input = input.trim();
        return input != null && ("Yes".equalsIgnoreCase(input) || 
                "y".equalsIgnoreCase(input) || "No".equalsIgnoreCase(input)
                || "n".equalsIgnoreCase(input));
    }

    public void closeOpenResources(){
        scanner.close();
    }

    //TODO: You may want to move your prompt text to a file
    //      later, possibly multiple files if you plan to support
    //      multiple languages. This applies to all prompts, not just
    //      the constants that follow this comment.
    private static final String INTRO_PREAMBLE = "Welcome to Who Wants to be a Millionaire! As I'm sure you know, you will have to answer 13 questions correctly in a row. \n But you have 3 lifelines to work with: 50/50, poll the audience, or ask a friend \n So, ";
    private static final String INTRO_POSTAMBLE = " lets begin! You have a chance to win ONE MILLION DOLLARS!!! \n\n\n\n\n";

    public void displayIntro(){
        String name = getUserName();
        displayOneLineMessage(INTRO_PREAMBLE + name + INTRO_POSTAMBLE);
    }

    public void displayErrorMessage(String msg){
        displayOneLineMessage(msg);
    }
}

Here is the View interface:

package gameRefactor;

import java.util.List;

/**
 * This interface specifies the functionality that
 * all views must implement. It will allow you to 
 * more easily create additional views in the future
 * if you decide to do so.
 */
public interface View {
    public void displayErrorMessage(String message);

    public void displayIntro();

    public void displayQuestion(Question question);

    public void displayAnswer(Answer answer);

    public void displayLifeLines(List<LifeLine> lifeLines);

    public void displayCallFriendResults();

    public void displayAudienceResults();

    public void displayOneLineMessage(String promptText);

    public UserResponse getUserResponseToQuestion(List<LifeLine> lifelines);

    public boolean getIsFinalAnswer();

    public String getUserName();

    public void closeOpenResources();
}

Finally the data model classes and enumerations:

The UserResponse class:

package gameRefactor;

/**
 * This class represents the user's response to a question,
 * which could be either a lifeline selection or one of the
 * answers.
 */
public class UserResponse {
    private LifeLine lifeline;
    private AnswerToken answerToken;

    public UserResponse(){}

    public UserResponse(AnswerToken token, LifeLine lifeLineValue){
        lifeline = lifeLineValue;
        answerToken = token;
    }

    public LifeLine getLifeline() {
        return lifeline;
    }
    public void setLifeline(LifeLine lifeline) {
        this.lifeline = lifeline;
    }
    public AnswerToken getAnswerToken() {
        return answerToken;
    }
    public void setAnswerToken(AnswerToken answerToken) {
        this.answerToken = answerToken;
    }
}

The Question class:

package gameRefactor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * This class represents a single question that could be 
 * presented to the player.
 */
public class Question {
    private String text;
    private AnswerToken correctAnswer;
    private List<Answer> answers;

    public Question(){}

    //TODO: You may wish to restrict the number of answers to 4
    //      which can be done in a few different ways. If you do
    //      implement this restriction within this class
    //      make sure to alter the setAnswers method as well.
    public Question(String txt, AnswerToken rightAnswer, Answer ... possibleAnswers){
        this.text = txt;
        this.correctAnswer = rightAnswer;
        this.answers = new ArrayList<>();
        this.answers.addAll(Arrays.asList(possibleAnswers));
    }

    public Set<AnswerToken> getAnswerTokens(){
        Set<AnswerToken> tokens = new HashSet<>();
        for(Answer answer: answers){
            tokens.add(answer.getToken());
        }
        return tokens;
    }

    public void removeAnswer(int index){
        answers.remove(index);
    }

    public void removeAnswer(Answer ans){
        answers.remove(ans);
    }

    public List<Answer> getAnswers() {
        return new ArrayList<>(answers);
    }

    public void setAnswers(List<Answer> choices) {
        this.answers = choices;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public AnswerToken getCorrectAnswer() {
        return correctAnswer;
    }

    public void setCorrectAnswer(AnswerToken answer) {
        this.correctAnswer = answer;
    }

    public boolean isCorrectAnswer(AnswerToken ans){
        //TODO: It's probably a good idea to ensure that a 
        //      question never has a null correct answer, 
        //      but for now this will do
        return correctAnswer == null ? ans == null : correctAnswer.equals(ans);
    }

    public List<Answer> getIncorrectAnswers(){
        List<Answer> incorrectAnswers = new ArrayList<>();
        for(Answer ans: answers){
            if(!isCorrectAnswer(ans.getToken()))
                incorrectAnswers.add(ans);
        }
        return incorrectAnswers;
    }
}

The LifeLine enum:

package gameRefactor;

/**
 * This enum represents all possible lifelines and
 * their textual representations.
 */
//TODO: If you do decide to add multi-language support you
//      will have to change how you represent the lifelines
//      since their text will not be constant.
public enum LifeLine {
    FIFTY_FIFTY("50/50"),
    POLL_AUDIENCE("Poll the audience"),
    CALL_A_FRIEND("Call a friend");

    private String text;
    private LifeLine(String text){
        this.text = text;       
    }
    public String getText() {
        return text;
    }

}

The AnswerToken enum:

package gameRefactor;

/**
 * This enum represents the tokens a player can enter in order to 
 * select one of the answers that has been presented.
 */
public enum AnswerToken {
    A,B,C,D
}

The Answer class:

package gameRefactor;

/**
 * This class represents an answer to a Question
 */
public class Answer {
    private String text;
    private AnswerToken token;

    public Answer(){}
    public Answer(AnswerToken tkn, String txt){
        token = tkn;
        text = txt;
    }
    public AnswerToken getToken() {
        return token;
    }
    public void setToken(AnswerToken token) {
        this.token = token;
    }
    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((text == null) ? 0 : text.hashCode());
        result = prime * result + ((token == null) ? 0 : token.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Answer other = (Answer) obj;
        if (text == null) {
            if (other.text != null)
                return false;
        } else if (!text.equals(other.text))
            return false;
        if (token == null) {
            if (other.token != null)
                return false;
        } else if (!token.equals(other.token))
            return false;
        return true;
    }

}