Java中用一维数组模拟栈数据结构

要求如下：

编写程序，使用一维数组，模拟栈数据结构 要求：
1、这个栈可以存储java中的任何引用类型的数据。
2、在栈中提供push方法模拟压栈。（栈满了，要有提示信息）
3、在栈中提供pop方法模拟弾栈。（栈空了，也有提示信息）
4、编写测试程序，new栈对象，调用push、pop方法来模拟压栈弹栈的动作。
5、假设栈的默认初始化容量是10（注意无参构造函数的编写方式）

方法一：
先看运行结果，不能滚动截图，我把运行结果复制粘贴过来了>_<

压栈请输入1,弾栈请输入0,结束程序请输入-1
1
==================================
压栈进行,请输入需要压入的数值：
1
压栈成功，栈顶元素为：1,栈帧指向0
栈内还有1个元素
栈内元素有：1 
1
==================================
压栈进行,请输入需要压入的数值：
2
压栈成功，栈顶元素为：2,栈帧指向1
栈内还有2个元素
栈内元素有：1 2 
1
==================================
压栈进行,请输入需要压入的数值：
3
压栈成功，栈顶元素为：3,栈帧指向2
栈内还有3个元素
栈内元素有：1 2 3 
1
==================================
压栈进行,请输入需要压入的数值：
4
压栈成功，栈顶元素为：4,栈帧指向3
栈内还有4个元素
栈内元素有：1 2 3 4 
1
==================================
压栈进行,请输入需要压入的数值：
5
压栈成功，栈顶元素为：5,栈帧指向4
栈内还有5个元素
栈内元素有：1 2 3 4 5 
1
==================================
压栈进行,请输入需要压入的数值：
6
压栈成功，栈顶元素为：6,栈帧指向5
栈内还有6个元素
栈内元素有：1 2 3 4 5 6 
1
==================================
压栈进行,请输入需要压入的数值：
7
压栈成功，栈顶元素为：7,栈帧指向6
栈内还有7个元素
栈内元素有：1 2 3 4 5 6 7 
1
==================================
压栈进行,请输入需要压入的数值：
8
压栈成功，栈顶元素为：8,栈帧指向7
栈内还有8个元素
栈内元素有：1 2 3 4 5 6 7 8 
1
==================================
压栈进行,请输入需要压入的数值：
9
压栈成功，栈顶元素为：9,栈帧指向8
栈内还有9个元素
栈内元素有：1 2 3 4 5 6 7 8 9 
1
==================================
压栈进行,请输入需要压入的数值：
10
压栈成功，栈顶元素为：10,栈帧指向9
栈内还有10个元素
栈内元素有：1 2 3 4 5 6 7 8 9 10 
1
==================================
压栈进行,请输入需要压入的数值：
栈已经满了，压栈失败
1
==================================
压栈进行,请输入需要压入的数值：
栈已经满了，压栈失败
0
==================================
弾栈进行
10
弹出元素为：10
栈内还有9个元素，栈帧指向8
栈内元素还有：1 2 3 4 5 6 7 8 9 
0
==================================
弾栈进行
9
弹出元素为：9
栈内还有8个元素，栈帧指向7
栈内元素还有：1 2 3 4 5 6 7 8 
0
==================================
弾栈进行
8
弹出元素为：8
栈内还有7个元素，栈帧指向6
栈内元素还有：1 2 3 4 5 6 7 
0
==================================
弾栈进行
7
弹出元素为：7
栈内还有6个元素，栈帧指向5
栈内元素还有：1 2 3 4 5 6 
0
==================================
弾栈进行
6
弹出元素为：6
栈内还有5个元素，栈帧指向4
栈内元素还有：1 2 3 4 5 
0
==================================
弾栈进行
5
弹出元素为：5
栈内还有4个元素，栈帧指向3
栈内元素还有：1 2 3 4 
0
==================================
弾栈进行
4
弹出元素为：4
栈内还有3个元素，栈帧指向2
栈内元素还有：1 2 3 
0
==================================
弾栈进行
3
弹出元素为：3
栈内还有2个元素，栈帧指向1
栈内元素还有：1 2 
0
==================================
弾栈进行
2
弹出元素为：2
栈内还有1个元素，栈帧指向0
栈内元素还有：1 
0
==================================
弾栈进行
1
弹出元素为：1
栈内还有0个元素，栈帧指向-1
栈内元素还有：
0
==================================
弾栈进行
0
栈已经空了，弹栈失败
0
==================================
弾栈进行
0
栈已经空了，弹栈失败
1
==================================
压栈进行,请输入需要压入的数值：
3
压栈成功，栈顶元素为：3,栈帧指向0
栈内还有1个元素
栈内元素有：3 
-1

进程已结束，退出代码 0

在这，其实使我自己写的，没意识到栈为空的时候，栈帧应该指向-1，所以把count（栈帧）初始值定义为了0，你们可以自己修改以下。代码如下：

class HomeWork01 {
    static Scanner sc=new Scanner(System.in);
    static int count=0;//栈帧是count，刚开始指向0
    static int k;//k是用户输入的数据，用来表示要执行什么操作
    public static void main(String[] args){
        Object[] arrs=new Object [10];//创建一个数组，模拟栈
        System.out.println("压栈请输入1,弾栈请输入0,结束程序请输入-1");
        while(sc.hasNextInt()){//多次输入
            k=sc.nextInt();
            if(k==1){
                System.out.println("==================================");
                System.out.println("压栈进行,请输入需要压入的数值：");

                push(arrs);//执行
            }
            else if(k==0){
                System.out.println("==================================");
                System.out.println("弾栈进行");
                pop(arrs);
            }
            else if(k==-1){
                return ;
            }
            else{
                System.out.println("==================================");
                System.out.println("输入错误");
            }
        }


    }

    public static void push(Object[] obj){
        if(count>=obj.length){
            System.out.println("栈已经满了，压栈失败");

        }
        else{
            obj[count]=sc.next();//将要压栈的数据压入栈内，即给数组赋值
            System.out.println("压栈成功，栈顶元素为："+obj[count]+",栈帧指向"+count);
            System.out.println("栈内还有"+(count+1)+"个元素");
            System.out.print("栈内元素有：");
            for(int i=0;i<(count+1);i++){
                System.out.print(obj[i]+" ");
            }
            System.out.println();
            count++;
        }
    }
    public static void pop(Object[] obj){
        System.out.println(count);

        if(count==0){

            System.out.println("栈已经空了，弹栈失败");

        }
        else{
            System.out.println("弹出元素为："+obj[count-1]);
            System.out.println("栈内还有"+(count-1)+"个元素，栈帧指向"+(count-2));
            System.out.print("栈内元素还有：");
            for(int i=0;i<count-1;i++){
                System.out.print(obj[i]+" ");
            }
            System.out.println();
            count--;
        }
    }
}

方式二
这是简易版的模拟栈只能固定输入输出，不能在控制台输出，但是栈帧刚开始是指向-1的。
先看运行结果：

代码如下：

//这是写方法的类
public class HomeWork01 {

    //index表示栈帧永远指向栈顶元素，那么这个默认值是-1最好
    //如果index采用0，表示栈帧指向了顶部元素的上方
    //如果index采用-1，表示栈帧指向了顶部元素
    private int index;
    private Object[] elements;

    //无参构造方法，默认初始化容量为10
    public HomeWork01() {//和声明变量的时候赋值是一样的，同时赋值。
        //一维数组动态初始化，默认初始化容量是10
        this.elements = new Object[10];
        //给index初始化
        this.index = -1;
    }

    //压栈方法
    public void push(Object obj) {
        if(index>=elements.length-1){
            System.out.println("栈已满，压栈失败！");
            return;
        }
        //程序能够走到这里，说明栈没满
        index++;
        elements[index]=obj;
        System.out.println("压栈"+obj+"压栈成功，栈帧指向"+index);
    }

    //弾栈的方法
    public void pop(){
        if(index<0){
            System.out.println("栈已空，弾栈失败!");
            return;
        }
        //程序能够执行到此处说明栈没有空
        //每取出一个元素，栈帧向下移动一位
        System.out.print("弾栈"+elements[index]);
        index--;
        System.out.println("元素成功，栈帧指向"+index);
    }

    public HomeWork01(Object[] elements) {
        this.elements = elements;
    }
下面是set和get方法，这里没有用到，可以不写
    public Object[] getElements() {
        return elements;
    }

    public void setElements(Object[] elements) {
        this.elements = elements;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }
}

//这是测试类
public class HomeWork010 {
    public static void main(String[] args) {
        //创建栈对象，初始化容量是10个
        HomeWork01 hwk=new HomeWork01();
        //调用方法压栈
        hwk.push(new Object());
        hwk.push(new Object());
        hwk.push(new Object());
        hwk.push(new Object());
        hwk.push(new Object());
        hwk.push(new Object());
        hwk.push(new Object());
        hwk.pop();
        hwk.pop();
        hwk.pop();
        hwk.pop();
        hwk.pop();
        hwk.pop();
        hwk.pop();
        hwk.pop();
    }
}

这两个各有优缺点吧，但是懒得改了哈哈哈。也是第一次写这种，模拟栈的，多少有点考虑不全面。
现在也是在努力学习java了，不知道能坚持到什么时候，总之，一起加油吧！