应用小练习-自定义栈

应用小练习-自定义栈

特点

1. 快

2. 先进后出，后进先出

重点

1. 泛型类/接口是泛型，实现的类也是泛型

2. 数组定义为Object类型，用时在强转(E)object

3. 默认的栈内数据长度-初始栈顶为-1；

4. 对于取出元素，先取值，在改变栈内数据长达

5. 泛型字母不可new；

方法

1. 入栈 2. 出栈 3. 查看栈顶元素 4. 判断是否空栈 5. 判断是否满栈

6. 返回栈内数据个数 7. 返回栈的存储长达 8. 查看某个元素 9.打印栈内元素

具体代码

1. 接口

package com.fr.stackText;
​
public interface IStack<E> {
    /**
     * 入栈
     * 
     * @param e
     *            传入的对象
     * @return 返回入栈是否成功
     */
    public boolean inStack(E e);
​
    /**
     * 出栈
     * 
     * @return 返回的元素
     */
    public E outStack();
​
    /**
     * 查看栈顶元素
     * 
     * @return 栈顶的元素
     */
    public E topStack();
​
    /**
     * 判断是否为空栈
     * 
     * @return 空栈返回true,否则返回false
     */
    public boolean isEmpty();
​
    /**
     * 判断是否满栈
     * 
     * @return 满栈返回true,否则返回false
     */
    public boolean isMax();
​
    /**
     * 返回栈的内容长度
     * 
     * @return 返回栈的内容长度
     */
    public int size();
​
    /**
     * 返回栈的长度
     * 
     * @return 长度值
     */
    public int getStackSize();
​
    /**
     * 打印
     */
    public void display();
}

2. 实现

public class MyStack<E> implements IStack<E> {

    private Object[] obj;
    private int stackLength;
    private int stackSize;
    private final static int DEFAULT_SIZE = 10;

    public MyStack() {
        this.stackLength = DEFAULT_SIZE;
        this.obj = new Object[DEFAULT_SIZE];
        this.stackSize = -1;
    }

    public MyStack(int stackLength) {
        if (stackLength <= 0)
            stackLength = DEFAULT_SIZE;
        this.stackLength = stackLength;
        this.obj = new Object[stackLength];
        this.stackSize = -1;
    }

    @Override
    public boolean inStack(E e) {
        if (isMax()) {
            // throw new ArrayIndexOutOfBoundsException(stackSize);
            return false;
        }
        stackSize++;
        obj[stackSize] = e;
        return true;
    }

    @Override
    public E outStack() {
        if (isEmpty()) {
            return null;
        } else {
            E e = (E) obj[stackSize];
            stackSize--;
            return e;
        }
    }

    @Override
    public E topStack() {
        if (isEmpty()) {
            return null;
        } else {
            return (E) obj[stackSize];
        }
    }

    @Override
    public boolean isEmpty() {
        return this.stackSize == -1 ? true : false;
    }

    @Override
    public boolean isMax() {
        return this.stackSize >= this.stackLength ? true : false;
    }

    @Override
    public int size() {
        return stackSize + 1;
    }

    @Override
    public int getStackSize() {
        return stackLength;
    }

    @Override
    public void display() {
        if (isEmpty()) {
            System.out.println("该栈中没有元素");
        } else {
            for (int i = 0; i <= this.stackSize; i++) {
                System.out.println(this.obj[i]);
            }
        }

    }

}