java代码简单实现栈

1. 基于数组简单实现

 /**
  * @author <a herf="mailto:yanwu0527@163.com">XuBaofeng</a>
  * @date 2019-11-29 14:37.
  * <p>
  * description: 基于数组实现栈
  */
 public class ArrayStack<T> {
     private static final Integer DEFAULT_SIZE = 10;
     /*** 栈 */
     private T[] items;
     /*** 栈顶所在角标 */
     private int top = -1;
     /*** 栈总容量 */
     private int size;

     public ArrayStack() {
         this(DEFAULT_SIZE);
     }

     public ArrayStack(int len) {
         if (len <= 0) {
             throw new IndexOutOfBoundsException("new instance error, len need more than 0, size: " + len);
         }
         size = len;
         items = (T[]) new Object[size];
     }

     /**
      * 判断栈是否为控
      *
      * @return
      */
     public boolean isEmpty() {
         return top == -1;
     }

     /**
      * 压栈
      *
      * @param t
      * @return
      */
     public boolean push(T t) {
         if (top == size - 1) {
             return false;
         }
         items[++top] = t;
         return true;
     }

     /**
      * 弹栈
      *
      * @return
      */
     public T pop() {
         if (isEmpty()) {
             return null;
         }
         T item = items[top];
         items[top--] = null;
         return item;
     }

     /**
      * 获取栈顶元素
      *
      * @return
      */
     public T top() {
         if (isEmpty()) {
             return null;
         }
         return items[top];
     }

     public static void main(String[] args) {
         ArrayStack<Integer> stack = new ArrayStack<>();
         for (int i = 0; i < DEFAULT_SIZE + 1; i++) {
             System.out.println("push: " + stack.push(i) + ", item: " + i);
         }
         for (int i = 0; i < DEFAULT_SIZE + 1; i++) {
             System.out.println("top: " + stack.top() + ", pop: " + stack.pop());
         }
     }
 }

2. 基于链表简单实现

 import lombok.AllArgsConstructor;
 import lombok.Data;

 /**
  * @author <a herf="mailto:yanwu0527@163.com">XuBaofeng</a>
  * @date 2019-12-10 17:27.
  * <p>
  * description: 基于链表实现栈
  */
 public class LinkedStack<T> {
     private static final Integer DEFAULT_SIZE = 10;
     /*** 栈顶元素 */
     private Node top;
     /*** 栈当前容量 */
     private Integer index;
     /*** 栈总容量 */
     private Integer size;

     public LinkedStack() {
         this(DEFAULT_SIZE);
     }

     public LinkedStack(Integer len) {
         if (len <= 0) {
             throw new IndexOutOfBoundsException("new instance error, len need more than 0, size: " + len);
         }
         index = -1;
         size = len;
     }

     /**
      * 判断栈是否为空
      *
      * @return
      */
     public Boolean isEmpty() {
         return top == null;
     }

     /**
      * 压栈
      *
      * @param t
      * @return
      */
     public boolean push(T t) {
         if (index >= size - 1) {
             return false;
         }
         Node old = top;
         top = new Node(t, old);
         index++;
         return true;
     }

     /**
      * 弹栈
      *
      * @return
      */
     public Node pop() {
         if (isEmpty()) {
             return null;
         }
         Node result = top;
         top = top.next;
         index--;
         return result;
     }

     /**
      * 获取栈顶元素
      *
      * @return
      */
     public Node top() {
         return top;
     }

     @Data
     @AllArgsConstructor
     private class Node {
         private T data;
         private Node next;
     }

     public static void main(String[] args) {
         LinkedStack<String> stack = new LinkedStack<>();
         for (int i = 0; i < DEFAULT_SIZE + 1; i++) {
             System.out.println("push: " + stack.push(String.valueOf(i)) + ", item: " + i);
         }
         for (int i = 0; i < DEFAULT_SIZE + 1; i++) {
             System.out.println("top: " + stack.top());
             System.out.println("pop: " + stack.pop());
         }
     }
 }