从堆栈中删除项目 - Java

Question

I have a stack with different colors represented as strings. What I need to do is remove a certain color from the tag. I've thought about creating an empty stack, popping the items from the initial stack into this stack except the color and then popping those items again to get the proper order. I'm unsure on how to pop items and place them in a new stack as well as how to remove a certain item. Thanks. This is the code I have so far.

import java.util.Collections;
import java.util.ListIterator;
import java.util.Scanner;
import java.util.Stack;

class CandiesStack{
//Methods to be used by stack

public static void showStack(Stack<String> candies){
    int num = 1;
    ListIterator<String> it = candies.listIterator(candies.size());
    while(it.hasPrevious()){
        System.out.println("Candy #" + num +" " + it.previous());
        num++;
    }
}

public static void removeYellow(Stack<String> candies){
    //Temporary Stack
    Stack<String> temp = new Stack<String>();       
    ListIterator<String> it = candies.listIterator(candies.size());

    while(it.hasNext()){
        String p = it.next();
            if(p.equals("yellow")){
                it.remove();
            }
    }
}
}

public class PezStack {

public static void main(String[] args) {
    System.out.println("--------------------------------------------------------------------------------------------------------");
    System.out.println("Welcome to PEZ Application using Stack");
    System.out.println("--------------------------------------------------------------------------------------------------------");
    Scanner kb = new Scanner(System.in);
    System.out.println("Here is the content of your PEZ container");
    System.out.println("--------------------------------------------------------------------------------------------------------\n");
    Stack<String> candies = new Stack<String>(); //Initial stack
    //Initiate the candies present in stack
    candies.push("yellow");
    candies.push("green");
    candies.push("pink");
    candies.push("orange");
    candies.push("green");
    candies.push("yellow");
    candies.push("yellow");
    candies.push("pink");
    candies.push("green");
    candies.push("yellow");
    candies.push("pink");
    candies.push("orange");
    Collections.shuffle(candies); //Shuffle content of the stack

    System.out.println("Current Pez Container");
    System.out.println("--------------------------------------------------------------------------------------------------------");

    CandiesStack.showStack(candies);

    System.out.println("Current Pez Container after remove yellow");
    System.out.println("--------------------------------------------------------------------------------------------------------");

    CandiesStack.removeYellow(candies);
    CandiesStack.showStack(candies);
}
}

Answer 1

You don't need a temporary stack at all. The problem you're having is that you're constructing your ListIterator incorrectly in removeYellow() .

When you construct your iterator here:

ListIterator<String> it = candies.listIterator(candies.size());

You're using the ListIterator<E> listIterator(int index) method, which

Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list. The specified index indicates the first element that would be returned by an initial call to next. An initial call to previous would return the element with the specified index minus one.

This means that the iterator you've made is starting at the end of the data in your stack, so your first call to it.hasNext() is going to be false .

When you want to use is the public ListIterator<E> listIterator() method, which

Returns a list iterator over the elements in this list (in proper sequence).

Then you can use your iterator to look through your data and remove all of the "yellow" entries as you already are doing:

public static void removeYellow(Stack<String> candies) {
    ListIterator<String> it = candies.listIterator();

    while (it.hasNext()) {
        String p = it.next();
        if (p.equals("yellow")) {
            it.remove();
        }
    }
}

Answer 2

Although I have a hard time to see a reason for using a stack when shuffling it and then accessing it ramdomly something like this should do the trick to remove all _yellow_s:

public static void removeYellow(Stack<String> candies) {
    while(candies.remove("yellow"));
}

I'd advice to use a list (eg ArrayList) to setup the candies you need and building the stack from that list new Stack<String>(list);

Answer 3

Why not use

stack.remove("yellow")

While it may seem that objects are not the same (two different Strings with the same values), Stack actually uses method equals to compare them. Therefore it is easy to do with strings, and anything else which is easily comparable with equals .

EDIT: OK,I get it now. So you can do it like that:

while (stack.remove("yellow"))