- 4. Preparation
- 5. Construction method
- 6. Method
- Field Summary
- Fields declared in class java.util.Vector
- Fields declared in class java.util.AbstractList
- Constructor Summary
- Method Summary
- Methods declared in class java.util.Vector
- Methods declared in class java.lang.Object
- Methods declared in interface java.util.Collection
- Methods declared in interface java.util.List
- Constructor Details
- Stack
- Method Details
- push
- pop
- peek
- empty
- search
- Field Summary
- Fields declared in class java.util.Vector
- Fields declared in class java.util.AbstractList
- Constructor Summary
- Method Summary
- Methods declared in class java.util.Vector
- Methods declared in class java.lang.Object
- Methods declared in interface java.util.Collection
- Methods declared in interface java.util.List
- Constructor Details
- Stack
- Method Details
- push
- pop
- peek
- empty
- search
- Java util stack source
- Field Summary
- Fields declared in class java.util.Vector
- Fields declared in class java.util.AbstractList
- Constructor Summary
- Method Summary
- Methods declared in class java.util.Vector
- Methods declared in class java.lang.Object
- Methods declared in interface java.util.Collection
- Methods declared in interface java.util.List
- Constructor Detail
- Stack
- Method Detail
- push
- pop
- peek
- empty
- search
4. Preparation
The Stack class is implemented using a dynamic array stack, with rules last in first out, pushing elements from the top of the stack and popping elements from the top of the stack. The stack is actually a sequence table with the rule of last in first out added. The Stack class inherits and extends functions on the basis of the Vector class.
It is best to look at the source code of Vector first and then at Stack Vector source code analysis of java collection
The attributes are the same as those of Vector
5. Construction method
/** * Create a stack empty constructor */ public Stack()
6. Method
push method, push the element onto the stack
/** * Push the element item onto the stack */ public E push(E item) < addElement(item); return item; >public synchronized void addElement(E obj) < modCount++; //Perform expansion operations /** * Increase the capacity of this vector (if necessary) to ensure that it can hold at least the number of components specified by the minimum capacity parameter. * If the capacity of the current array is less than minCapacity, then increase the capacity and increase the length of the array * The length of the new array is equal to the length of the original array plus the increment capacityIncrement. * If the increase in capacityIncrement is less than or equal to 0, it will be automatically amplified twice. * If the amplification is twice the original or smaller than minCapacity, then minCapacity is used as the length of the Object array. */ ensureCapacityHelper(elementCount + 1); //Insert an element at the top of the stack elementData[elementCount++] = obj; >
/** * Pop elements from the top of the stack */ public synchronized E pop() < E obj; int len = size(); //Get the top element of the stack, but do not pop the element obj = peek(); //Delete the top element of the stack removeElementAt(len - 1); return obj; >
/** * Get the subscript as the length of the array minus one, which is the final value, which also conforms to the rules of the stack, and pops the element from the top of the stack */ public synchronized E peek() < int len = size(); if (len == 0) throw new EmptyStackException(); return elementAt(len - 1); >public synchronized E elementAt(int index) < if (index >= elementCount) < throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount); > return elementData(index); > //Get the corresponding value in the array by index E elementData(int index)
Class Stack
The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with five operations that allow a vector to be treated as a stack. The usual push and pop operations are provided, as well as a method to peek at the top item on the stack, a method to test for whether the stack is empty , and a method to search the stack for an item and discover how far it is from the top.
When a stack is first created, it contains no items.
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:
Deque stack = new ArrayDeque();
Field Summary
Fields declared in class java.util.Vector
Fields declared in class java.util.AbstractList
Constructor Summary
Method Summary
Methods declared in class java.util.Vector
Methods declared in class java.lang.Object
Methods declared in interface java.util.Collection
Methods declared in interface java.util.List
Constructor Details
Stack
Method Details
push
pop
peek
empty
search
Returns the 1-based position where an object is on this stack. If the object o occurs as an item in this stack, this method returns the distance from the top of the stack of the occurrence nearest the top of the stack; the topmost item on the stack is considered to be at distance 1 . The equals method is used to compare o to the items in this stack.
Report a bug or suggest an enhancement
For further API reference and developer documentation see the Java SE Documentation, which contains more detailed, developer-targeted descriptions with conceptual overviews, definitions of terms, workarounds, and working code examples. Other versions.
Java is a trademark or registered trademark of Oracle and/or its affiliates in the US and other countries.
Copyright © 1993, 2023, Oracle and/or its affiliates, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
All rights reserved. Use is subject to license terms and the documentation redistribution policy.
Class Stack
The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with five operations that allow a vector to be treated as a stack. The usual push and pop operations are provided, as well as a method to peek at the top item on the stack, a method to test for whether the stack is empty , and a method to search the stack for an item and discover how far it is from the top.
When a stack is first created, it contains no items.
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:
Deque stack = new ArrayDeque();
Field Summary
Fields declared in class java.util.Vector
Fields declared in class java.util.AbstractList
Constructor Summary
Method Summary
Methods declared in class java.util.Vector
Methods declared in class java.lang.Object
Methods declared in interface java.util.Collection
Methods declared in interface java.util.List
Constructor Details
Stack
Method Details
push
pop
peek
empty
search
Returns the 1-based position where an object is on this stack. If the object o occurs as an item in this stack, this method returns the distance from the top of the stack of the occurrence nearest the top of the stack; the topmost item on the stack is considered to be at distance 1 . The equals method is used to compare o to the items in this stack.
Report a bug or suggest an enhancement
For further API reference and developer documentation see the Java SE Documentation, which contains more detailed, developer-targeted descriptions with conceptual overviews, definitions of terms, workarounds, and working code examples. Other versions.
Java is a trademark or registered trademark of Oracle and/or its affiliates in the US and other countries.
Copyright © 1993, 2023, Oracle and/or its affiliates, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
All rights reserved. Use is subject to license terms and the documentation redistribution policy.
Java util stack source
The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with five operations that allow a vector to be treated as a stack. The usual push and pop operations are provided, as well as a method to peek at the top item on the stack, a method to test for whether the stack is empty , and a method to search the stack for an item and discover how far it is from the top. When a stack is first created, it contains no items. 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:
Deque stack = new ArrayDeque();
Field Summary
Fields declared in class java.util.Vector
Fields declared in class java.util.AbstractList
Constructor Summary
Method Summary
Methods declared in class java.util.Vector
Methods declared in class java.lang.Object
Methods declared in interface java.util.Collection
Methods declared in interface java.util.List
Constructor Detail
Stack
Method Detail
push
pop
peek
empty
search
Returns the 1-based position where an object is on this stack. If the object o occurs as an item in this stack, this method returns the distance from the top of the stack of the occurrence nearest the top of the stack; the topmost item on the stack is considered to be at distance 1 . The equals method is used to compare o to the items in this stack.
Report a bug or suggest an enhancement
For further API reference and developer documentation see the Java SE Documentation, which contains more detailed, developer-targeted descriptions with conceptual overviews, definitions of terms, workarounds, and working code examples.
Java is a trademark or registered trademark of Oracle and/or its affiliates in the US and other countries.
Copyright © 1993, 2023, Oracle and/or its affiliates, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
All rights reserved. Use is subject to license terms and the documentation redistribution policy.