第2章动态数组_03节_栈的实现

首先，什么是栈？

栈是限定仅在表尾进行插入和删除操作的线性表

Stack实现

1.Stack接口定义

package P1接口;

/**
 栈的定义
 */
public interface Stack<E> extends Iterable<E> {
    public int size();
    public boolean isEmpty();
    //入栈 进栈一个元素 在线性表的表尾添加一个元素
    public void push(E element);
    //出栈 弹出一个元素 在线性表的表尾删除一个元素
    public E pop();
    //查看当前栈顶元素 并不是移除 查看线性表中最后一个元素
    public E peek();
    public void clear();
}

2…实现子类ArrayStack

因为栈本身就是一种特殊的线性表，所以我们可以借用之前完成的ArrayList来实现我们的ArrayStack.

package P2.线性结构;

import P1接口.Stack;

import java.util.Iterator;

public class ArrayStack<E> implements Stack<E>{
    private ArrayList<E> list;

    public ArrayStack() {
        list = new ArrayList<>();
    }

    public ArrayStack(int capacity) {
        list = new ArrayList<>(capacity);
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public void push(E element) {
        list.add(element);
    }

    @Override
    public E pop() {
        return list.remove(list.size() - 1);
    }

    @Override
    public E peek() {
        return list.get(list.size() - 1);
    }

    @Override
    public void clear() {
        list.clear();
    }

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        return list.toString();
    }

    @Override
    public boolean equals(Object o) {
        if( o == null) {
            return false;
        }
        if( this == o) {
            return true;
        }
        if (o instanceof  ArrayStack) {
            ArrayStack other = (ArrayStack) o;
            return this.list.equals(other.list);
        }
        return false;
    }
}

3.测试类

package P0.测试;

import P2.线性结构.ArrayStack;

public class TestArrayStack {
    public static void main(String[] args) {
        ArrayStack<Integer> stack01 = new ArrayStack<>();
        ArrayStack<Integer> stack02 = new ArrayStack<>(15);
        for (int i = 1; i <= 12; i++) {
            stack01.push(i);
            stack02.push(i);
        }
        System.out.println(stack01);
        System.out.println(stack02);
        System.out.println(stack01.equals(stack02));

        System.out.println(stack01.pop());
        System.out.println(stack01);
        System.out.println(stack01.peek());
    }
}

5.运行结果