java复习之栈+栈实现计算器

java复习之栈

栈的代码实现

package learn;

public class MyStack {
    public static void main(String[] args) {
        ArrayStack arrayStack = new ArrayStack(10);
        arrayStack.push(1);
        arrayStack.push(4);
        arrayStack.push(2);
        arrayStack.push(12);
        arrayStack.list();

    }

}
class ArrayStack{
    private int maxSize;
    private int[] stack;
    private int top=-1;

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack=new int[maxSize];
    }
    public boolean isFull(){
        return top==maxSize-1;
    }
    public boolean isEmpty(){
        return top==-1;
    }
    public void push(int num){
        if(isFull()){
            System.out.println("满了，满了");
            return;
        }
        top++;
        stack[top]=num;
    }
    public int pop(){
        if(isEmpty()){
            System.out.println("都干净了，啥也没了");
            throw new RuntimeException("真没了！");
        }
        int value=stack[top];
        top--;
        return  value;
    }
    public void list(){
        if(isEmpty()){
            return;
        }
        for(int i=top;i>=0;i--){
            System.out.println(stack[i]);
        }
    }
}

计算器的实现

给一串字符串，设置一个index来遍历这个字符串，如果是数字，就进数栈，如果是符号，就分情况进行：
若符号栈为空，则直接进栈，
若有操作符，就进行比较，如果，当前操作符的优先级小于后者等于栈中的操作符，就从数栈中pop两个数，在符号栈中pop一个符号，进行运算，得到的结果放入数栈，将当前操作符放入符号栈，如果当前操作符的优先级大于栈中的操作符，就直接进入符号栈。
表达式扫描完之后，顺序从数栈和符号栈中pop相应的数和符号，并运行
最后数栈中只剩一个数字，就是表达式结果。
这里mark一个以前没学的知识，关于char与int的混用，

public class Test {
    public static void main(String[] args) {
        int num=97;
        char c=(char) num;
        System.out.println(c);
        char m= '9';
        int b=m;
        System.out.println(b);
    }
}

char类型都可以隐式的转换成int类型的数字，而int类型的需要显式转换成char类型
这样的原因是char保存的是ascii码，int获取的也是char的ascii码的数值。

下面是计算器的代码实现

package learn;

public class MyStack {
    public static void main(String[] args) {
        String ex="3+2*6-2";
        ArrayStack stack1 = new ArrayStack(10);
        ArrayStack stack2 = new ArrayStack(10);
        int num1;
        int num2;
        int res;
        int oper;
        char ch=' ';
        int index=0;
        while(true){
            ch=ex.substring(index,index+1).charAt(0);
            if(stack2.isOper(ch)){
                if(!stack2.isEmpty()){
                    if(stack2.priority(ch)<=stack2.priority(stack2.peek())){
                        num1=stack1.pop();
                        num2=stack1.pop();
                        oper=stack2.pop();
                        res=stack2.cal(num1,num2,oper);
                        stack1.push(res);
                        stack2.push(ch);

                    }else{
                        stack2.push(ch);
                    }
                }else{
                    stack2.push(ch);
                }
            }else{
                stack1.push(ch-48);//ascii中，'1'比1大48
            }
            index++;
            if(index>=ex.length()){
                break;
            }
        }
     while (true){
         if(stack2.isEmpty()){
             break;
         }
         num1=stack1.pop();//这个时候，只剩下加减了，乘除已经在刚才的读的过程中算出来了，直接重复就行了
         num2=stack1.pop();
         oper=stack2.pop();
         res=stack2.cal(num1,num2,oper);
         stack1.push(res);
     }
        System.out.println(stack1.pop());
    }

}
class ArrayStack{
    private int maxSize;
    private int[] stack;
    private int top=-1;

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack=new int[maxSize];
    }
    public boolean isFull(){
        return top==maxSize-1;
    }
    public boolean isEmpty(){
        return top==-1;
    }
    public void push(int num){
        if(isFull()){
            System.out.println("满了，满了");
            return;
        }
        top++;
        stack[top]=num;
    }
    public int pop(){
        if(isEmpty()){
            System.out.println("都干净了，啥也没了");
            throw new RuntimeException("真没了！");
        }
        int value=stack[top];
        top--;
        return  value;

    }
    public int peek(){
        return stack[top];
    }
    public void list(){
        if(isEmpty()){
            return;
        }
        for(int i=top;i>=0;i--){
            System.out.println(stack[i]);
        }
    }
    public int priority(int oper){
        if(oper=='*'||oper=='/'){
            return 1;
        }else if(oper=='+'||oper=='-'){
            return  0;
        }else
            return  -1;
    }
    public boolean isOper(int val){
        return val=='+'||val=='-'||val=='*'||val=='/';
    }
    public int cal(int num1,int num2,int oper){
        int res=0;
        switch (oper){
            case '+':
                res=num1+num2;
                break;
            case '-':
                res=num2-num1;
                break;
            case '*':
                res=num1*num2;
                break;
            case '/':
                res=num2/num1;
                break;
            default:
                break;

        }
        return res;
    }
}

这个计算器只是用来算单位数的，多位数需要在向stack1这个数栈的时候进行判断，判断是否是多位数，用一个temp看字符串的下一位，如果下一位是运算符直接入栈，如果是数字，则把数字提出来，拼起来，同时注意字符的最后一位，进行判断，否则会出空指针异常。