链表下压栈

import java.util.Iterator;

/**
 * 链表实现下压栈
 * 成员变量：栈顶指针 first、节点数量 count 、节点内部类 Node()
 * 私有方法
 * 公开方法：入栈 push、出栈 pop、大小 size、判断为空 isEmpty
 * 要求：泛型、迭代器
 */
public class LinkedStack<Item> implements Iterable<Item> {
    private Node first; //指向栈顶的指针
    private int count; //栈中节点的数量

    public LinkedStack() {
        first = null;
        count = 0;
    }

    private class Node<Item> { //私有化内部类，使得该类只能在外部类范围内访问
        private Item value;  //外部类也可以访问内部类的私有化成员
        private Node next;

        public Node() {
            this.value = null;
            this.next = null;
        }

        public Node(Item value, Node next) {
            this.value = value;
            this.next = next;
        }
    }

    /**
     * 向栈中压入一个数据
     * 注意点：向空栈中压入一个节点，修改数量
     * @param e
     */
    public void push(Item e) {
        first = new Node(e,first);
        ++count;
    }

    /**
     * 栈中弹出一个结点
     * 注意点：空栈的情况，修改数量
     * @return
     */
    public Item pop() {
        if(first==null) return null;//空栈，返回空
        Item temp = (Item) first.value;
        first=first.next;
        --count;
        return temp;
    }

    public int size() {
        return count;
    }

    public boolean isEmpty() {
        if(count==0) return true;
        return false;
    }

    @Override
    public Iterator<Item> iterator() {
        return new Iterator<Item>() {
            Node i = first;
            @Override
            public boolean hasNext() {
                if(i!=null) return true;
                return false;
            }

            @Override
            public Item next() {
                Item temp = (Item) i.value;
                i = i.next;
                return temp;
            }
        };
    }
}

/**
 * 测试案例
 */
public class TestCase {
    public static void main(String[] args) {
        LinkedStack<Integer> integers = new LinkedStack<>();
        integers.push(1);
        integers.push(2);
        integers.push(3);
        integers.push(4);
        integers.push(5);
        System.out.println(integers.pop());
        System.out.println(integers.isEmpty());
        System.out.println(integers.size());
        System.out.println("===================");
        for(Integer e : integers){
            System.out.println(e);
        }
    }
}

//结果
5
false
4
===================
4
3
2
1