Java实战（六）用链表实现栈（自定义异常、接口）

定义栈接口，并用链表实现，并采用自定义异常处理栈满和栈空时的错误操作。

(1)定义接口
(2)定义异常类
(4)采用链表实现栈类
(5)定义测试类

代码示例：

package xiaoji.xiaohan;

/*
    定义栈接口，并分别采用数组和链表实现，并采用自定义异常处理栈满和栈空时的错误操作。
    (1)定义接口
    (2)定义异常类
    (4)采用链表实现栈类
    (5)定义测试类
 */

//自定义异常类，继承Exception类
class StackException extends Exception
{
    int index = 0;

    public StackException(int index) {
        this.index = index;
    }

    @Override
    public String toString() {
        return "StackExceptionAt{ " + "index=" + index + " }";
    }
}

//定义接口
interface MyStack
{
    int pop() throws StackException;
    void push(int value) throws StackException;
    int size();
}



//实现接口，定义栈类
class ArrayStack implements MyStack
{
    //定义栈大小
    int size = 0;

    class Element
    {
        //节点的值
        public int value = 0;
        //指向下一个节点
        private Element next = null;
    }

    //头结点
    private Element header = null;

    //初始化链表
    public ArrayStack(int size) {
        header = new Element();
        header.value = 0;
        header.next = null;
        this.size = size;
    }

    //重写接口方法
    @Override
    public int pop() throws StackException {
        //判断栈是否为空
        if (size() == 0) throw new StackException(-1);

        //若不为空
        Element temp = header;
        while(temp.next.next != null)
        {
            temp=temp.next;
        }

        int value = temp.next.value;
        temp.next = null;
        return value;
    }

    @Override
    public void push(int value) throws StackException {
        //若栈满，抛出异常
        if (this.size == size()) throw new StackException(size+1);

        //若未满，在尾部压栈
        //创建一个新的节点
        Element e = new Element();
        e.value = value;
        //若插入到头节点后
        if (header.next == null)
        {
            header.next = e;
        }
        //不是插入到头节点后
        else
        {
            Element temp = header;
            //寻找最后一个元素
            while (temp.next != null)
            {
                temp = temp.next;
            }
            temp.next = e;
        }
    }
    /**
     * 链表长度
     * */
    public int size()
    {
        Element temp = header;
        int size=0;
        while(temp.next!=null)
        {
            size++;
            temp=temp.next;
        }
        return size;
    }
}


public class Test6 {
    public static void main(String[] args) {
        System.out.println("链表实现：");

        //定义一个长度大小为3的栈
        ArrayStack arrayStack = new ArrayStack(3);

        //此时队列为空,取出元素会产生异常
        try {
            arrayStack.pop();
        } catch (StackException e) {
            System.out.println(e.toString());
        }

        //此时加入插入四个元素（>3）队列会产生异常
        try {
            arrayStack.push(1);
            System.out.println("栈顶压栈的值为：1");
            arrayStack.push(2);
            System.out.println("栈顶压栈的值为：2");
            arrayStack.push(3);
            System.out.println("栈顶压栈的值为：3");
            arrayStack.push(4);
            System.out.println("栈顶压栈的值为：4");
        } catch (StackException e) {
            System.out.println(e.toString());
        }

        //尝试取出栈顶元素
        try {
            System.out.println("取出栈顶元素的值为："+arrayStack.pop());
            System.out.println("取出栈顶元素的值为："+arrayStack.pop());
            System.out.println("取出栈顶元素的值为："+arrayStack.pop());
            System.out.println("取出栈顶元素的值为："+arrayStack.pop());
        } catch (StackException e) {
            System.out.println(e.toString());
        }
    }
}

运行结果：

参考文章：https://www.cnblogs.com/lixiaolun/p/4643886.html