Thread: how could I display a stack as FIFO instead of LIFO

guys, if you have a stream of numbers: 1 2 20 -4 99 -3 -20. And you need to insert them into an Stack and display the positive numbers in the order they were insert them(if 1 is first, then 1 is first out: FIFO), and for negatives numbers display them in the order they have in the stack. 1) do I need two stacks for this scenario Stack<Integer> negatives, Stack<Integer> positives, or can I get away with putting all numbers in one stack? my implementation is with two stacks, but I would like to know if can be done with only one stack, and what would it be the solution for the displaying of positive numbers in (FIFO). By the way I display positive numbers in FIFO using a tempStack, is there any other way to display a stack in reverse order without creating a temp stack. here's the code

public static void main(String[] args) throws IOException {
 
        Stack<Integer> pNum = new Stack();
        Stack<Integer> nNum = new Stack();       
 
        int num;
 
        Scanner in = new Scanner(System.in);  
        System.out.println("enter series of number: ");         
        int i = 0;
        while(in.hasNextInt()) {
           num = in.nextInt(); 
           if(num ==  -1) {
               nNum.push(num);
               break;
           }               
           else if(num > 0)
               pNum.push(num);
           else
               nNum.push(num);            
        }       
 
        Stack<Integer> tempNum = new Stack();
 
        while(!pNum.isEmpty()) {
            tempNum.push(pNum.top());
            pNum.pop();
        }
 
        while(!tempNum.isEmpty()) {
            System.out.print(tempNum.top()+" ");
            tempNum.pop();
        }
 
        System.out.println();
 
        while(!nNum.isEmpty()){
            System.out.print(nNum.top()+" ");
            nNum.pop();
        }       
 
    }

that line didn't work... it didn't take a stack!

After changing type parameters Collections.reverse(pNum); is the way to go

There are plenty of ways to do this. I'd advise you avoid using relics of the past like Stack in favor of using the newer Deque collection. I quote:

...
A more complete and consistent set of LIFO stack operations is provided by the Deque interface and its implementations, which should be used in preference to this class. For example:
...

You can even convert a Deque into a LIFO Queue using Collections.asLifoQueue(), if need be.

Anyways, here's one way to solve your problem.

import java.io.PrintStream;
 
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Iterator;
import java.util.Scanner;
 
public final class EchoSequences {
 
  private EchoSequences() { }
 
  private static void print(final Deque<Integer>... sequences) {
    final PrintStream output = System.out;
    for (final Deque<Integer> seq : sequences) {
      final Iterator<Integer> cursor = seq.iterator();
      while (cursor.hasNext()) {
        output.print(cursor.next());
        output.print(' ');
      }
      output.println();
    }
  }
 
  public static void main(String[] argv) {
    final Deque<Integer> positives = new ArrayDeque<Integer>();
    /* technically not strictly negatives as it also may contain 0 */
    final Deque<Integer> negatives = new ArrayDeque<Integer>();
 
    final Scanner input = new Scanner(System.in);
    while (input.hasNextInt()) {
      int n = input.nextInt();
      if (n > 0) {
        positives.add(n);
      } else {
        negatives.push(n);
        if (n == -1) {
          break;
        }
      }
    }
 
    print(positives, negatives);
  }
}

On the topic of your own code, I'd advise not calling top()/pop() separately, as you can merely replace the top() call with a pop() and keep the same functionality.