You need to put things into a holding area quickly, and retrieve them
in last-in, first-out order. This is a common data structuring
operation and is often used to reverse the order of objects. The
basic operations of any stack are
push( )
(add to
stack), pop( )
(remove from stack), and
peek( )
(examine top element without removing). A
simple stack for stacking only
ints
is in class
ToyStack
:
/** Toy Stack. */ public class ToyStack { /** The maximum stack depth */ protected int MAX_DEPTH = 10; /** The current stack depth */ protected int depth = 0; /* The actual stack */ protected int stack[] = new int[MAX_DEPTH]; /* Implement a toy stack version of push */ protected void push(int n) { stack[depth++] = n; } /* Implement a toy stack version of pop */ protected int pop( ) { return stack[--depth]; } /* Implement a toy stack version of peek */ protected int peek( ) { return stack[depth]; } }
If you are not familiar with the basic idea of a stack, you should
work through the code here; if you are, skip ahead. While looking at
it, of course, think about what happens if pop( )
is called when push( )
has never been called, or
if push( )
is called to stack more data than will
fit.
The java.util.Stack
operation behaves in a
similar fashion. However,
instead of being built just for one type of primitive, such as Java
int
, the methods of
java.util.Stack
are defined in terms of
java.lang.Object
so that any kind of object can be
put in and taken out. A cast will be needed when popping objects, if
you wish to call any methods defined in a class below
Object
.
For an example of a java.util.Stack
in operation,
Section 5.19 provides a simple stack-based numeric
calculator.
18.225.254.192