1.栈(Stack)

栈：栈又名堆栈，它是一种运算受限的线性表，其限制是只能在表的一端进行插入和删除操作，这一端称为栈顶。插入新的元素又称为进栈、入栈或压栈，删除元素又称为出栈或者退栈。

栈的实现代码和常见操作如下：

Stack.java

package com.simoniu.stack;

public class Stack<E> {

    //底层实现是一个数组
    private E[] arr;
    //栈顶
    private int top;
    public Stack() {
        arr = (E[]) new Object[10];
        top = -1;
    }

    public Stack(int maxSize) {
        arr = (E[]) new Object[maxSize];
        top = -1;
    }

    /**
     * 添加数据
     *
     * @param e
     */
    public void push(E e) {
        arr[++top] = e;
    }
    /**
     * 弹出数据
     *
     * @return
     */
    public E pop() {
        return arr[top--];
    }
    /**
     * 查看数据
     */
    public E peek() {
        return arr[top];
    }
    /**
     * 判断是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return top == -1;
    }
    /**
     * 判断是否满了
     *
     * @return
     */
    public boolean isFull() {
        return top == arr.length - 1;
    }
}

StackTest.java

package com.simoniu.stack;

public class StackTest {

    public static void main(String[] args) {
        Stack s = new Stack(100);
        s.push("banana");
        s.push("watermelon");
        s.push("pear");
        s.push("apple");
        s.push("strawberry");

        while(!s.isEmpty()){
            System.out.println(s.pop());
        }
    }
}

运行结果：
strawberrey
apple
pear
waterwelon
banana

2.队 (Queue)

队列：和栈一样，队列也是一种受限的线性表，不一样的是队列只能在队头（front）删除元素，在队尾（rear）插入元素。

队的实现代码和常见操作如下：

Queue.java

package com.simoniu.queue;

public class Queue<E> {
    // 底层实现数组
    private E[] arr;
    // 队头
    private int front;
    // 队尾
    private int rear;
    // 元素数量
    private int elementsCount;

    public Queue() {
        arr = (E[])new Object[10];
        elementsCount = 0;
        front = 0;
        rear = -1;
    }

    public Queue(int maxSize) {
        arr = (E[])new Object [maxSize];
        elementsCount = 0;
        front = 0;
        rear = -1;
    }

    /**
     * 添加数据<br/>
     * 队尾添加
     *
     * @param value
     */
    public void push(E value) {
        if(rear == arr.length - 1){
            rear = -1;
        }
        arr[++rear] = value;
        elementsCount++;
    }

    /**
     * 移除数据<br/>
     * 队头移除
     *
     * @return
     */
    public E pop() {
        E result = arr[front++];
        if(front == arr.length){
            front = 0;
        }
        elementsCount--;
        return result;
    }

    /**
     * 查看队头数据
     *
     * @return
     */
    public E peek() {
        return arr[front];
    }

    /**
     * 是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return elementsCount == 0;
    }

    /**
     * 是否满了
     *
     * @return
     */
    public boolean isFull() {
        return elementsCount == arr.length;
    }

}

QueueTest.java

package com.simoniu.queue;

import com.simoniu.stack.Stack;

public class QueueTest {
    public static void main(String[] args) {
        Queue q = new Queue(100);
        q.push("banana");
        q.push("watermelon");
        q.push("pear");
        q.push("apple");
        q.push("strawberry");

        while(!q.isEmpty()){
            System.out.println(q.pop());
        }
    }
}

运行结果：
banana
watermelon
pear
apple
strawberry