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());
        }
    }
}