手写堆栈，实现堆栈功能并实现堆栈元素迭代遍历（FILO：先进后出的迭代方式）（秋招）

package Stack;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;

/**
 * @program: Study
 * @description: 手写堆栈，实现堆栈功能并实现堆栈自定义迭代遍历接口
 * @param:
 * @author: Hanson
 * @create: 2020-10-09 20:50
 **/
public class TestStack<R>{

    //Object数组 保存栈数据信息
    private Object [] data;

    //栈顶指针，默认-1.即栈未初始化，原子类，解决自增自减原子性问题
    private AtomicInteger top = new AtomicInteger(-1);

    //默认栈容量
    private static int capacity = 4;

    //构造初始化
    public TestStack(){
        this(capacity);
    }
    //有参构造初始化
    public TestStack(int size){
        if (size > 0) this.data = new Object[size];
        else this.data = new Object[capacity];
    }
    //入栈
    public R push(R obj){
        if (data == null || isFull()) resize();
        data[top.incrementAndGet()] = obj;
        return obj;
    }
    //出栈
    public R pop(){
        if (isEmpty()) {
            data = new Object[capacity];//恢复为栈原始容量,也可以置空，随意就好
//            throw new RuntimeException("栈空异常");//根据情况选择抛出异常或者返回空元素
            return null;
        }
        R obj = (R) data[top.get()];
        data[top.get()] = null;//清理元素,防止内存溢出
        top.decrementAndGet();//栈顶 - 1
        return obj;
    }
    //扩容
    public void resize(){
        if (data == null) {
            data = new Object[capacity];//延时初始化，如果没有上面的无参构造，一定要写这里！！！
            return;
        }
        Object[] newData = new Object[(top.get() + 1)<<1];
        if (top.get() + 1 >= 0) System.arraycopy(data, 0, newData, 0, top.get() + 1);
        data = newData;
    }
    //栈空？
    public boolean isEmpty(){
        return top.get() < 0;
    }
    //栈满？
    public boolean isFull(){
        return top.get() + 1 >= size();
    }

    //栈大小
    public int size(){
        return data.length;
    }
    //栈元素个数
    public int getSize(){
        return top.get() + 1;
    }
    //获取栈索引元素
    public R elementData(int index){
        return (R) data[index];
    }

    //自定义迭代接口
    private interface StackEnumeration<R>{
        boolean hasMoreElements();
        R nextElement();
        default StackIterator<R> asIterator(){
            return new StackIterator<>() {
                @Override
                public boolean hasNext() {
                    return hasMoreElements();
                }

                @Override
                public R next() {
                    return nextElement();
                }
            };
        }
    }
    //自定义迭代器接口
    private interface StackIterator<R>{
        boolean hasNext();
        R next();
        default void forEachRemaining(Consumer<? super R> action){
            Objects.requireNonNull(action);
            while (hasNext()){
                action.accept(next());
            }
        }
    }
    //自定义迭代方法
    public StackEnumeration<R> elements(boolean flag){
        if (!flag)
            return new StackEnumeration<R>() {
                int count = top.get();
                @Override
                public boolean hasMoreElements() {
                    return count >= 0;
                }

                @Override
                public R nextElement() {
                    synchronized (TestStack.this){
                        if (count >= 0){
                            return elementData(count--);//反向迭代FILO
                        }
                        throw new NoSuchElementException("没有元素");
                    }
                }

            };
        else
            return new StackEnumeration<R>() {
                int count = 0;
                @Override
                public boolean hasMoreElements() {
                    return count < getSize();
                }

                @Override
                public R nextElement() {
                    synchronized (TestStack.this){
                        if (count <= getSize()){
                            return elementData(count++);//正向迭代,FIFO
                        }
                        throw new NoSuchElementException("没有元素");
                    }
                }

            };
    }

    public static void main(String[] args){
        TestStack<Integer> stack = new TestStack<Integer>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        System.out.println("=============入栈==============");
        System.out.println("isFull? -->" + stack.isFull());
        System.out.println("栈元素个数： -->" + stack.getSize());
        System.out.println("栈大小：" + stack.size());
        System.out.println("isEmpty？-->" + stack.isEmpty());
        System.out.println("=============出栈==============");
        System.out.println("出栈元素：" + stack.pop());
        System.out.println("出栈元素：" + stack.pop());
        System.out.println("出栈元素：" + stack.pop());
        System.out.println("出栈元素：" + stack.pop());
        System.out.println("出栈元素：" + stack.pop());
        System.out.println("出栈元素：" + stack.pop());
        System.out.println("isFull? -->" + stack.isFull());
        System.out.println("栈元素个数： -->" + stack.getSize());
        System.out.println("栈大小：" + stack.size());
        System.out.println("isEmpty？-->" + stack.isEmpty());
        System.out.println("==============正向迭代遍历栈元素FIFO=================");
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.elements(true).asIterator().forEachRemaining(System.out::println);
        System.out.println("==============反向迭代遍历栈元素FILO=================");
        stack.elements(false).asIterator().forEachRemaining(System.out::println);
    }
}