Java 如何使程序忽略ArrayIndexOutOfBonds错误？

我用Java编写了一个程序，将中缀表达式转换为posfix并计算posfix表达式，但是，某些表达式会给出“Java.lang.ArrayIndexOutOfBoundsException:-1”错误消息。如何使程序忽略此错误并仍然计算表达式

示例：1+2*3^2/3-4*（2-1）+9变为123^2*3/+421-*-9+，结果为6， 但是1+2*3^2/3-4*（2-1）+9+给出了这个错误

主要类别：

---

当您的程序试图访问内存中为数组分配的空间之外的数据时，可能会发生各种奇怪的事情。您可能会覆盖一些重要的系统文件，或者您的程序可能会执行得很好。Java是一种检查过的语言，意味着每次访问数组元素时都会进行检查。如果它检测到这样一个错误，它就会抛出一个异常，但什么也没有发生（这与C不同）。你这里的东西真的是个虫子。你应该做的是修复这个bug。我不会费心看你的代码，但你应该确保程序在任何时候都只访问数组边界内的元素。

你能做的：以一种不会遇到这些问题的方式修复代码，看看异常发生的地方，它们发生的原因并阻止输入到达异常发生的点。您不应该。。。因为这是你造成的…使用一个try-catch块。但是，我建议您解决问题，而不是避免它。

import java.io.IOException;
import java.util.*;
public class Avaliador {
   private Pilha Pilha1;
   private String input;
   private String output = "";
   public Avaliador(String in) {
      input = in;
      int TamanhoPilha = input.length();
      Pilha1 = new Pilha(TamanhoPilha,false);
   }
   public String Transformar() {
      for (int j = 0; j < input.length(); j++) {
         char ch = input.charAt(j);
         switch (ch) {
            case '*': 
            case '/':
                temOperador(ch, 2); 
                break; 
            case '+':
            case '-':
               temOperador(ch, 1); 
               break;   
            case ')': 
                temParentesis(ch);
                break;
            case '(': 
               Pilha1.Inserir(ch);
               break;
            default: 
               output = output + ch; 
               break;
         }
      }
      while (!Pilha1.Vazio()) {
         output = output + Pilha1.Remover();
      }
      return output; 
   }
   public void temOperador(char opLer, int n1e) {
      while (!Pilha1.Vazio()) {
         char op = Pilha1.Remover();
         if (op == '(') {
            Pilha1.Inserir(op);
            break;
         } else {
            int n2e;
            if (op == '+' || op == '-')
            n2e = 1;
            else
            n2e = 2;
            if (n2e < n1e) { 
               Pilha1.Inserir(op);
               break;
            } 
            else output = output + op;
         }
      }
      Pilha1.Inserir(opLer);
   }
   public void temParentesis(char ch) { 
      while (!Pilha1.Vazio()) {
         char chx = Pilha1.Remover();
         if (chx == '(')
         break;
         else output = output + chx; 
      }
   }

   public int CalculoExpressao(String exp) {
       int n1,n2;
        Scanner operadores = new Scanner(exp);
        Pilha Pilha2=new Pilha(exp.length(),true);
        while (operadores.hasNext()) {
            if (operadores.hasNextInt()) {
                Pilha2.Inserir(operadores.nextInt());
            } else {
                n2=Pilha2.Remover2();
                n1=Pilha2.Remover2();
                String op = operadores.next();

                if (op.equals("+")) {
                    Pilha2.Inserir(n1 + n2);
                } else if (op.equals("-")) {
                    Pilha2.Inserir(n1 - n2);
                } else if (op.equals("*")) {
                    Pilha2.Inserir(n1 * n2);
                } else {
                    Pilha2.Inserir(n1 / n2);
                }
            }
        }
        return Pilha2.Remover2();
  }
   public static boolean checarParen(String check){
       Pilha Pilha3=new Pilha(check.length(),false);
       for(int a = 0; a < check.length(); a++)
       {
           char pal = check.charAt(a);
           if(pal == '(')
               Pilha3.Inserir(pal);
           else if(pal == ')')
           {
               if(Pilha3.Vazio())
                   return false;
               switch(pal)
               {
                   case ')':
                       if (Pilha3.Remover() != '(')
                           return false;
                       break;
                   default:
                       break;
               }
           }
       }
       if(Pilha3.Vazio())
           return true;
       return false;
   }
   public static void checarErros(String input){
       int i=0,g=0,gg=0,erros=0;
       String letrasz="",chval="0123456789()+-*/^";

       for(i=0;i<input.length();i++){
              char cju=input.charAt(i);
              if(chval.indexOf(cju)==-1){
                  letrasz+=cju+",";
              }
          }
       i=0;
       if(!letrasz.isEmpty()){
              letrasz=letrasz.substring(0,letrasz.length()-1);
              System.out.println("ERRO: A expressão possui operadores inválidos: "+letrasz+".");
              erros++;
          }
       if(!checarParen(input)){
              while(i<input.length()){
                  char cti=input.charAt(i);
                  if(cti=='('){g++;}
                  else if(cti==')'){gg++;}
                  i++;
              }
              int huh=0;
              if(g>gg){
                  huh=g-gg;
                  if(huh>1){System.out.println("ERRO: Há "+huh+" parênteses '(' sem a presença de parênteses ')' sucessores.");
                  }else{System.out.println("ERRO: Há um parênteses '(' sem a presença de um parênteses ')' sucessor.");}
              }else{
                  huh=gg-g;
                  if(huh>1){System.out.println("ERRO: Há "+huh+" parênteses ')' sem a presença de parênteses '(' antecessores.");
                  }else{System.out.println("ERRO: Há um parênteses ')' sem a presença de um parênteses '(' antecessor.");}

              }
              erros++;
          }
       if(erros>0){
           System.exit(0);
       }
   }
   public static void main(String[] args) throws IOException {
      Scanner scan=new Scanner(System.in);
      boolean ler=true;
      String input="",output,resultado="";
      if(!ler){
          /*
          input="1+2*3^2/3-4*(2-1)+9";
          1+2*3^2/3-4*(2-1)+9
          */
          input="1+2*3^2/3-4*(2-1)+9";
      }else{
          System.out.println("Digite a expressão a ser avaliada: ");
          input=scan.nextLine();
      }
      checarErros(input);
      Avaliador Transformacao = new Avaliador(input);
      output = Transformacao.Transformar();
      for (int j = 0; j < output.length(); j++) {
          char tu = output.charAt(j);
          resultado+=tu+" ";
      }
      System.out.println("Expressão Infixa: "+input+'\n'+"Expressão Posfixa: "+output+'\n'+"Resultado: "+Transformacao.CalculoExpressao(resultado));
   }
}

public class Pilha {
    private int tammax,tammax2;
    boolean het=false;
    private char[] VetorP;
    private int[] VetorI;
    private int top;
    private int top2;
    public Pilha(int max,boolean hetz) {
     if(!hetz){
         tammax = max;
             VetorP = new char[tammax];
             top = -1;
     }else{
         tammax2 = max;
             VetorI = new int[tammax2];
             top2 = -1;
     }
    }
    public char Checar() {
        return VetorP[top];
     }
    public char Remover() {
        return VetorP[top--];
     }
    public void Inserir(char j) {
       VetorP[++top] = j;
    }
    public void Inserir(int i){
      VetorI[++top2]=i;
    }
    public int Remover2(){
        return VetorI[top2--];
    }
    public boolean Vazio() {
       return (top == -1);
    }
    public void setPilha2(){
      top2=-1;
    }
    public void getTop(){
      System.out.println(this.top);
    }
}