【Java数据结构与算法-顺序表02(栈)】

1.栈Stack

1.1栈的定义

栈是限定仅在表尾进行插入删除操作的线性表.
我们把允许插入和删除的一端叫做栈顶，另一端自然叫做栈底；
没有数据元素的栈称为空栈；
栈的特点是后进先出（Last In First Out）的线性表，简称LIFO结构，栈本身就是一个线性表，其数据元素具有线性关系，只不过它是一种特殊的线性表而已。
栈的插入叫进栈，也称压栈，入栈，栈的删除，叫做出栈，也称弹栈。

1.2基于ArrayList实现ArrayStack

1.创建Stack接口

package ifce;

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实现类
比较简单，主要是调用顺序表01的ArrayList的方法；

package linestract;

import ifce.Stack;

import java.util.Iterator;
import java.util.Objects;

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 boolean equals(Object o) {
   
        if(o == null){
   
            return false;
        }
        if (this == o) return true;
        if(o instanceof ArrayStack){
   
            ArrayStack other = (ArrayStack)o;
            return other.list.equals(this.list);
        }
        return false;
    }

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

1.3ArrayStack的测试类

package test;

import linestract.ArrayStack;

import java.util.Iterator;

public class ArrayStackTest {
   
    public static void main(String[] args) {
   
        ArrayStack<Integer> stack01 = new ArrayStack<>();
        ArrayStack<Integer> stack02 = new ArrayStack<>(15);
        for(int i  = 0;i<=11;i++){
   
            stack01.push(i);
            stack02.push(i);
        }
        System.out.println(stack01.toString());
        System.out.println(stack02.toString());
        System.out.println(stack01.equals(stack02));
        System.out.println("========================");
        System.out.println(stack01.pop());
        System.out.println(stack01.toString());
        System.out.println(stack01.peek());
        System.out.println("=========================");
        Iterator<Integer> it = stack02.iterator();
        while(it.hasNext()){
   
            System.out.println(it.next());
        }