Java之链表实现栈结构

package com.wzlove.stack;

import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * 链表实现栈结构:栈的结构是先进后出,所以栈的结点也包括了两个部分
 *  1.构造函数初始化栈
 *  2.判空操作
 *  3.栈的长度操作
 *  4.入栈
 *  5.出栈
 *  6.返回最近入栈的元素
 *  7.格式化输出
 *
 * @author WZLOVE
 * @create 2018-07-14 21:53
 */
public class LinkedStack<Item> implements Iterable<Item> {
    /**
     * 表示栈的长度
     */
    private int n;

    /**
     * 首节点
     */
    private Node first;

    /**
     * 结点的结构
     */
    private class Node{
        private Item item;
        private Node next;
    }

    /**
     * 构造方法初始化栈
     */
    public LinkedStack() {
        first = null;
        n = 0;
        assert check();
    }

    /**
     * 判断栈是否为空
     * @return boolean类型,空为true,不空为false
     */
    public boolean isEmpty(){
        return first == null;
    }

    /**
     * 返回栈的长度
     * @return
     */
    public int size(){
        return n;
    }

    /**
     * 入栈方法
     * @param item 入栈的元素
     */
    public void push(Item item){
        // 保存旧的栈
        Node oldFirst = first;
        // 创建结点
        first = new Node();
        // 保存新的结点
        first.item = item;
        first.next = oldFirst;
        // 修改栈的长度
        n++;
        assert check();
    }

    /**
     * 出栈方法
     * @return Item 出栈的元素
     */
    public Item pop(){
        if(isEmpty()){
            throw new NoSuchElementException("栈为空,没有元素");
        }
        // 保存栈顶元素
        Item item = first.item;
        // 移动指针
        first = first.next;
        // 减小长度
        n--;
        assert check();
        return item;
    }

    /**
     * 返回最近入栈的元素
     * @return Item 入栈的元素
     */
    public Item peek(){
        if(isEmpty()){
            throw new NoSuchElementException("栈为空,没有元素");
        }
        return first.item;

    }

    /**
     * 格式化输出
     * @return
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for(Item item : this){
            sb.append(item + " ");
        }
        return sb.toString();
    }

    @Override
    public Iterator<Item> iterator() {
        return new ListIterator();
    }

    /**
     * 迭代器类
     * @return
     */
    private class ListIterator implements Iterator<Item>{

        /**
         * 复制栈,进行遍历
         */
        private Node current = first;

        /**
         * 判断有无更多元素,有返回true,没有返回false
         * @return
         */
        @Override
        public boolean hasNext() {
            return current != null;
        }

        /**
         * 返回当前元素,移动指针
         * @return
         */
        @Override
        public Item next() {
            if(!hasNext()){
                throw new NoSuchElementException("没有更多的元素");
            }
            Item item = current.item;
            current = current.next;
            return item;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("不支持该操作");
        }
    }

    // check internal invariants
    private boolean check() {

        // check a few properties of instance variable 'first'
        if (n < 0) {
            return false;
        }
        if (n == 0) {
            if (first != null) return false;
        }
        else if (n == 1) {
            if (first == null)      return false;
            if (first.next != null) return false;
        }
        else {
            if (first == null)      return false;
            if (first.next == null) return false;
        }

        // check internal consistency of instance variable n
        int numberOfNodes = 0;
        for (Node x = first; x != null && numberOfNodes <= n; x = x.next) {
            numberOfNodes++;
        }
        if (numberOfNodes != n) return false;

        return true;
    }

    /**
     * 主方法进行测试
     * @param args
     */
    public static void main(String[] args) {
        // 初始化栈
        LinkedStack<String> linkedStack = new LinkedStack<>() ;
        // 输出栈的长度
        System.out.println("初始化后栈的长度:"+linkedStack.size());
        System.out.println("=====================================");
        // 入栈
        linkedStack.push("迪丽热巴");
        linkedStack.push("李溪芮");
        linkedStack.push("杨紫");
        linkedStack.push("杨幂");
        // 迭代器遍历
        Iterator<String> iterator = linkedStack.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("====================================");
        // 出栈
        System.out.println(linkedStack.pop());
        System.out.println("====================================");
        // 输出栈的长度
        System.out.println("经过操作后的长度为:" + linkedStack.size());
    }
}