简单的JAVA四则运算

import java.util.Scanner;

public class SortObject {

 private static int intercePosition = 0; // 记录单个运算数据的长度

 private static int[] intercePositionIndex = null; // 记录“（”的下标

 private static int[] intercePositionEnd = null; // 记录“）”的下标

 public static void main(String[] args) {

  Scanner input = new Scanner(System.in);

  do {

   System.out.println("请输入你要计算的字符串(注意：只能输入数字和加，减，乘除符号;输入完毕后,请直接回车):");

   String numberString = input.next().trim();

   // 判断输入的运算字符串是否符合规定

   if (ispassString(numberString) == false) {

    System.out.println("您输入的计算字符串有误,请正确输入!");

   } else {

    // 计算结果返回

    System.out.println(interceResult(numberString));

   }

  } while (true);

 }

 // 判断是否有带括号的运算字符串存在

 private static String interceResult(String str) {

  String result = str;

  char[] numberString = str.toCharArray(); // 1+2+(1*2+1-1*2+5)+2+(1+5+9+10-11)+1*5/2+3

  // 1+8-9+(1*8/2-5+(1+2+8))+4/5*8/3*2

  int IndexStart = 0; // 记录“（”的实际数量

  int EndStart = 0; // 记录“）”的实际数量

for (int i = 0; i < numberString.length; i++) {

   if ('(' == numberString[i]) {

    // 记录最后一个正括号的位置

    IndexStart = i;

   }

   if (')' == numberString[i]) {

    // 记录反括号的最初始下标的位置

    EndStart = i;

    // 截取最里面一个括号里的运算字符串

    result = result.substring(IndexStart + 1, EndStart);

    // 截取括号的运算字符串进行运算,生成新的运算字符串

    result = str.substring(0, IndexStart)

      + interceptOperation(result, '*', '/')

      + str.substring(EndStart + 1, str.length());

    // 回调执行，其它小括号的运算字符串

    return interceResult(result);

   }

   if (i == numberString.length - 1)

    if (EndStart == 0)

     break;

  }

  // 不存在括号了，再进行混合运算

  result = interceptOperation(str, '*', '/');

  return result;

 }

 // 不带括号的四则运算

 private static String interceptOperation(String operationNumber, char a,

   char b) {

  String mess = operationNumber;

  char[] stringOperation = mess.toCharArray();

  // 循环遍历运算字符串，并做相应的运算

for (int i = 0; i < stringOperation.length; i++) {

   // 判断运算符所在的索引

   if (stringOperation[i] == a || stringOperation[i] == b) {

    if (i != 0) {

     // 运算符前的第一个数

     double num1 = interceptNumIndex(mess.substring(0, i));

     // 记录第一个数据的长度

     int frontPosition = intercePosition;

     // 运算符前的第二个数

     double num2 = interceptNumEnd(mess.substring(i + 1,

       stringOperation.length));

     // 记录第二个数据的长度

     int backPosition = intercePosition;

     // 算完乘除，将结果替换到原来运算的位置，得到新的运算字符串

     String IndexMess = mess.substring(0, i - frontPosition + 1);

     String IndexResult = "";

     // 判断是否运算到最后的结果了

     if (IndexMess.indexOf('+') == -1

       && IndexMess.indexOf('*') == -1

       && IndexMess.indexOf('/') == -1

       && IndexMess.lastIndexOf('-') == -1)

      IndexMess = "";

     if (IndexMess != "")

      IndexResult = IndexMess.lastIndexOf('-') == IndexMess

        .length() - 1 ? IndexMess.substring(0, i

        - frontPosition) : IndexMess;

     // 组装新的运算字符串

     mess = IndexResult// mess.substring(0,i-frontPosition+1)

       + reslutString("" + stringOperation[i], num1, num2)

       + mess.substring(i + backPosition + 1);

     // 0.111/1212/2/2/2/2/2/2/2

     if (mess.lastIndexOf('-') == 0 && mess.indexOf('+') == -1

       && mess.indexOf('*') == -1

       && mess.indexOf('/') == -1) {

      break;

     }

     // 回调，继续运算

     return interceptOperation(mess, a, b);// 1+7-5+/3+4-6*8/2+4-6

    } else

     continue;

   }

   if (i == stringOperation.length - 1) {

    // 递归出口，判断是否还有运算字符串在

    if (mess.indexOf('+') != -1 || mess.indexOf('-') != -1)

     return interceptOperation(mess, '+', '-');

    break;

   }

  }

  return mess;

 }

 // 截取第二个数

 private static double interceptNumEnd(String str) {

  double a = 0;

  int InrerceIndex = 0;

  char[] stringOperation = str.toCharArray();

  boolean ispas = false; // 记录是否为负数

for (int i = 0; i < stringOperation.length; i++) {

   switch (stringOperation[i]) {

   case '*':

   case '/':

   case '+':

   case '-':

    InrerceIndex = i;

    if (i != 0) // 判断该数是否为负数

     ispas = true;

    break;

   default:

    break;

   }

   if (ispas)

    break;

  }

  // 判断此数据是否在运算字符串的最后一位

  if (InrerceIndex == 0) {

   a = Double.parseDouble(str);

   intercePosition = str.length();

   if (ispas)

    intercePosition++;

  } else {

   a = Double.parseDouble(str.substring(0, InrerceIndex));

   // 记录数据的真实长度

   intercePosition = str.substring(0, InrerceIndex).length();

  }

  return a;

 }

 // 截取第一个数

 private static double interceptNumIndex(String str) {

  double a = 0; // 记录数据

  int InrerceIndex = 0; // 记录运算符的位置

  boolean temp = false; // 记录数据前运算符的状态

  char[] stringOperation = str.toCharArray();

for (int i = stringOperation.length - 1; i >= 0; i--) {

   switch (stringOperation[i]) {

   case '*':

   case '/':

   case '+':

   case '-':

    InrerceIndex = i;

    temp = true;

    break;

   default:

    break;

   }

   if (temp)

    break;

  }

  // 判断此数据是否在运算字符串的第一位

  if (InrerceIndex == 0) {

   a = Double.parseDouble(str);

   intercePosition = str.length();

   // if(temp)

   // intercePosition++;

  } else {

   a = Double.parseDouble(str.substring(InrerceIndex, str.length()));

   // 记录数据的真实长度

   intercePosition = str.substring(InrerceIndex, str.length())

     .length();

  }

  return a;

 }

 // 计算结果

 private static double reslutString(String operation, double num1,

   double num2) {

  double sumResult = 0;

  if (operation.equals("*"))

   sumResult = num1 * num2;

  if (operation.equals("-"))

   sumResult = num1 - num2;

  if (operation.equals("/"))

   sumResult = num1 / num2;

  if (operation.equals("+"))

   sumResult = num1 + num2;

  return sumResult;

 }

 // 判断是否正确输入运算方式

 private static boolean ispassString(String messString) {

  boolean ispass = false;

  boolean operationIspass = true; // 记录被除数的状态

  int ai = 0; // 记录是否有运算符号的存在

  char[] IsString = messString.toCharArray();

  int num1 = 0;

  int num2 = 0;

for (int i = 0; i < IsString.length; i++) {

   // 记录有几对小括号的存在

   if ('(' == IsString[i])

    num1++;

   if (')' == IsString[i])

    num2++;

   // 判断除数是否为零

   if ('/' == IsString[i] && IsString[i + 1] == '0')

    operationIspass = false;

   // 判断是否输入了运算符合

   if (IsString[i] == '+' || IsString[i] == '-' || IsString[i] == '*'

     || IsString[i] == '/')

    ai++;

   if (i == IsString.length - 1)

    if (ai == 0)

     num2++;

  }

  if (operationIspass)

   if (num1 == num2)

    ispass = true;

  return ispass;

 }

}