数组模拟栈，实现简单回文判断

一、模拟栈

public class ArrayStack {

    /**
     * 栈的大小
     */
    private int maxStack;

    /**
     * 数组用来模拟栈
     */
    private int[] stack;

    /**
     * 表示栈顶所在的位置，默认情况下没有数据时，是-1
     */
    private int top = -1;

    /**
     * 有参构造
     * @param maxStack 栈的大小
     */
    public ArrayStack(int maxStack){
        this.maxStack = maxStack;
        stack = new int[maxStack];
    }

    /**
     * 判断是否已经满栈
     */
    public boolean isFull(){
        return this.top == this.maxStack - 1;
    }

    /**
     * 判断是否是空栈
     */
    public boolean isEmpty(){
        return this.top == -1;
    }

    /**
     * 压栈
     */
    public void push(int val){
        // 判断是否已经栈满
        if (isFull()){
            throw new RuntimeException("栈满了");
        }
        // 栈未满则自增
        top++;
        // 将值存入对应的数组下标
        stack[top] = val;
    }

    /**
     * 弹栈
     */
    public int pop(){
        // 判断是否为空栈
        if (isEmpty()){
            throw new RuntimeException("空栈");
        }
        // 不为空则弹栈
        int value = stack[top];
        top--;
        return value;
    }

    /**
     * 查看栈中所以元素
     */
    public void list(){
        //是否空栈
        if (isEmpty()){
            throw new RuntimeException("空栈");
        }
        // 遍历数组
        for (int i = 0; i < stack.length; i++){
            System.out.printf("stack[%d]=%d\n",i,stack[i]);
        }
    }

    /**
     * 栈中元素存在的个数
     */
    public int length(){
        return this.top + 1;
    }

二、判断回文

public class TestStack {

    public static void main(String[] args) {

        /**
         * 回文数据
         * 回文: aba racecar
         * 需求:通过上面以数组模拟栈来判断一个字符串是否是一个回文数据
         */

        System.out.println(detecation("aba"));
        // detecation("aba");

    }

    public static boolean detecation(String val){
        /**
         * 初始化栈对象,栈最大10
         */
        ArrayStack arrayStack = new ArrayStack(10);

        /**
         * 获取字符串长度
         */
        int length = val.length();

        // 把字符串数据逐次获取字符压栈至数组中
        for (int i = 0; i < length; i++){
            arrayStack.push(val.charAt(i));
        }

        /**
         * 获取
         */
        // 初始化字符串
        String newVal = "";
        // 固定数组初始长度
        int length1 = arrayStack.length();
        // 遍历数组
        for (int i = 0; i < length1; i++){
            // 是否空栈
            if (!arrayStack.isEmpty()){
                // 强转为char字符
                char pop = (char)arrayStack.pop();
                // 拼接字符
                newVal = newVal + pop;
            }
        }
        // 返回结果
        return val.equals(newVal);

    }
}