通过建立一个简单的菜单来实现进栈、出栈、显示当前栈内元素和退出操作，所有进栈元素通过键盘获取._编写进栈,出栈,显示栈中全部元素程序

栈的实现和菜单的实现

注释中有详尽的代码解释

1、通过建立一个简单的菜单来实现进栈、出栈、显示当前栈内元素和退出操作，所有进栈元素通过键盘获取；

2、利用栈完成后序表达式求值算法。

有问题可以私信问。。。。

import java.util.*;

public class MyStackTest {
    public static void main(String[] args) throws Exception {


        MyStack<Object> myStack = new MyStack<>();
        boolean flag = true;
        System.out.println("================主菜单================");
        System.out.println("1、显示当前栈内元素");
        System.out.println("2、进栈");
        System.out.println("3、出栈");
        System.out.println("4、显示栈顶元素");
        System.out.println("5、后缀表达式求值");
        System.out.println("6、退出");
        System.out.println("================主菜单================");
        System.out.println("请选择需要的功能：");
        while (flag){

            Scanner sc = new Scanner(System.in);
            int msgFromKey = sc.nextInt();
            if (msgFromKey == 1){
                System.out.println("栈内元素为：");
                System.out.println(myStack);
                System.out.println("输出完毕，请继续选择功能");
            }
            else if (msgFromKey == 2){
                System.out.println("请输入需要进栈的元素：");
                String msg = sc.next();
                myStack.push(msg);
                System.out.println("进栈成功，请继续选择功能");
            }
            else if (msgFromKey == 3){
                if (myStack.isEmpty()){
                    System.out.println("对不起，栈已经空了哦，不要再出栈了");
                }else {
                    Object temp = myStack.pop();
                    System.out.println("元素-->"+temp+"出栈成功");
                    System.out.println("请继续选择功能");
                }
            }
            else if (msgFromKey == 4){
                if (myStack.isEmpty()){
                    System.out.println("栈空了哦~");
                }else {
                    Object temp = myStack.peek();
                    System.out.println("栈顶元素为：");
                    System.out.println(temp);
                    System.out.println("输出完成,请继续选择功能");
                }
            } else if (msgFromKey == 5) {
                System.out.println("请输入后缀表达式，以英文逗号分离:");
                String expression = sc.next();
                MyStack expressionStack = new MyStack<>();
                String[] data;
                data = expression.split(",");

                for (int i = 0 ; i < data.length ; i++){
                    //这里判断是否是一个数字，如果是数字就入栈
                    if (Character.isDigit(data[i].charAt(0))){
                        //入栈
                        expressionStack.push(Integer.parseInt(data[i]));
                    }else {
                        //这里代表不是数字
                        //弹出两个数字进行运算
                        int opa = (int) expressionStack.pop();
                        int opb = (int) expressionStack.pop();
                        int c = 0;
                        switch (data[i]){
                            case "+":
                                c = opa + opb;
                                break;
                            case "-":
                                c = opb - opa;
                                break;
                            case "*":
                                c = opa * opb;
                                break;
                            case "/":
                                c = opb/opa;
                                break;
                        }
                        //将计算完城后的结果压入栈
                        expressionStack.push(c);
                    }
                }
                System.out.println("计算结果为：");
                System.out.println(expressionStack.peek());
                //运算之后要将栈清空，防止下一次运算出错
                //1,2,3,4,-,*,+,5,+   4
                //9,3,1,-,3,*,+,10,2,/,+   20
                while (!expressionStack.isEmpty()){
                    expressionStack.pop();
                }
                System.out.println("输出完毕，请继续选择功能");
            } else if (msgFromKey == 6) {
                System.out.println("Bye Bye ~");
                System.out.println("Bye Bye ~");
                System.out.println("Bye Bye ~");
                //改变标志 退出循环
                flag = false;
            } else {
                System.out.println("输入的数字有误，请重新输入");
            }
        }

    }
}


class MyStack<E>{

    //栈元素个数
    private int size;
    //实际的数组
    private Object[] contents;
    //栈帧
    private int top;
    //初始容量
    private int capacity=10;

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    //构造方法 创建一个容量为10的数组 栈帧指向-1 大小为0
    public MyStack(){
        contents = new Object[capacity];
        top = -1;
        size = 0;
    }

        /**
        *@Description 判断是否为空 如果栈帧为-1 就是空栈
        *@Date 2021/5/17
        *@Time 18:51
        */
    public boolean isEmpty() {
        return this.top==-1;
    }


    public int getTop() {
        return top;
    }

    public void setTop(int top) {
        this.top = top;
    }

        /**
        *@Description 入栈操作，首先如果数组满了 就需要扩容 不需要扩容的情况下 直接在栈帧+1处赋值 栈帧上移 容量+1
        *@Date 2021/5/17
        *@Time 18:52
        */
    public void push(E e){
        if(contents.length==size)
            ensureCapacity(size*2+1);
        contents[top+1] = e;
        top++;
        size++;

    }

        /**
        *@Description peek 查看栈顶元素 如果是空栈就返回一个Exception 返回一个Object
        *@Date 2021/5/17
        *@Time 18:53
        */
    public Object peek() throws Exception {
        if(isEmpty())
            new EmptyStackException();
        Object temp = contents[top];
        return temp;
    }

        /**
        *@Description 弹栈操作，如果空栈就返回错误 然后保存要弹出的元素，返回此元素
        *@Return Object temp
        *@Author Mr.Lu
        *@Date 2021/5/17
        *@Time 18:55
        */
    public Object pop() throws Exception {
        if(isEmpty())
            new EmptyStackException();
        Object temp = contents[top];

        contents[top] = null;

        top--;
        size--;

        return temp;
    }

    public void ensureCapacity(int capacity) {
        //如果需要拓展的容量比现在数组的容量还小,则无需扩容
        if (capacity<size)
            return;

        E[] old = (E[]) contents;
        contents = (E[]) new Object[capacity];
        //复制元素
        for (int i=0; i<size ; i++)
            contents[i]=old[i];
    }

        /**
        *@Description 调用System.out.println()时候会调用toString()方法
         * 新建StringBuilder 来拼接字符串
        *@Author Mr.Lu
        *@Date 2021/5/17
        *@Time 20:29
        */
    @Override
    public String toString() {
        //创建一个sb
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0 ; i < size;i++){
            //如果是最后一个元素 在这个后面就不添加逗号
            if (i == size-1 ){
                sb.append(contents[i]);
            }else {
                //不是最后一个元素 就在后面加一个逗号
                sb.append(contents[i]);
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238