栈

 1 import java.util.Iterator;
 2 import java.util.Scanner;
 3 
 4 public class ResizingArrayStack<Item> implements Iterable<Item> {
 5     
 6     private Item[] a = (Item[]) new Object[1];        //item
 7     private int n = 0;                                //size
 8 
 9     public boolean isEmpty(){
10         return n == 0;
11     }
12 
13     public int size(){
14         return n;
15     }
16 
17     private void resize(int max){
18         //new Item[max]
19         Item[] tmp = (Item[]) new Object[max];
20         for(int i = 0; i < n; i ++){
21             tmp[i] = a[i];
22         }
23         a = tmp;
24     }
25 
26     public void push(Item item){
27         if(n == a.length){
28             //full
29             resize(n * 2);
30         }
31         a[n ++] = item;
32     }
33 
34     public Item pop(){
35         Item item = a[-- n];
36         a[n] = null;            //avoid loitering
37 
38         if(n > 0 && n == a.length / 4){
39             //too large
40             resize(a.length / 2);
41         }
42 
43         return item;
44     }
45 
46     public Iterator<Item> iterator(){
47         return new ReverseArrayIterator();
48     }
49 
50     private class ReverseArrayIterator implements Iterator<Item> {
51 
52         private int i = n;
53         
54         public boolean hasNext(){
55             return i > 0;
56         }
57 
58         public Item next(){
59             return a[-- i];
60         }
61 
62         public void remove(){}
63         
64     }
65 
66     public static void main(String[] args) {
67         Scanner in = new Scanner(System.in);
68 
69         ResizingArrayStack<String> s = new ResizingArrayStack<>();
70         while(in.hasNext()){
71             String item = in.next();
72             if(!item.equals("-")){
73                 s.push(item);
74             }
75             else if(!s.isEmpty()){
76                 System.out.print(s.pop() + " ");
77             }
78         }
79 
80         System.out.println("(" + s.size() + " left on stack)");
81     }
82 }

 1 import java.util.Scanner;
 2 import java.util.Iterator;
 3 
 4 public class Stack<Item> implements Iterable<Item>{
 5 
 6     private class Node{
 7         //LinkedList Node
 8         Item item = null;
 9         Node next = null;
10     }
11 
12     private Node first = null;        //top
13     private int n = 0;                //size
14 
15     public boolean isEmpty(){
16         return first == null;
17     }
18 
19     public int size(){
20         return n;
21     }
22 
23     public void push(Item item){
24         Node oldFirst = first;
25         first = new Node();
26         first.item = item;
27         first.next = oldFirst;
28         n ++;
29     }
30 
31     public Item pop(){
32         Item item = first.item;
33         first = first.next;
34         n --;
35         return item;
36     }
37 
38     public Iterator<Item> iterator(){
39         return new ListIterator();
40     }
41 
42     private class ListIterator implements Iterator<Item>{
43         private Node current = first;
44 
45         public boolean hasNext(){
46             return current != null;
47         }
48 
49         public Item next(){
50             Item item = current.item;
51             current = current.next;
52             return item;
53         }
54 
55         public void remove(){}
56     }
57     
58     public static void main(String[] args) {
59         Scanner in = new Scanner(System.in);
60 
61         Stack<String> s = new Stack<>();
62         while(in.hasNext()){
63             String item = in.next();
64             if(!item.equals("-")){
65                 s.push(item);
66             }
67             else if(!s.isEmpty()){
68                 System.out.print(s.pop() + " ");
69             }
70         }
71 
72         System.out.println("(" + s.size() + " left on stack)");
73     }
74 }