숫자를 계산할 문자열 파싱

Question

문자열은 다음과 같습니다. 2+4*4/2 문자열은 더 길거나 짧을 수 있지만 두 경우 모두 구문 분석하고 나누기 및 곱하기를 먼저 더하기 및 빼기 전에 계산해야합니다. 그때 문자열 배열로 문자열을 넣어 했는가

는 :

double answer = 0; 
for(int i=0; i< array.length; i++) { 
    if (array[i].equals(“+”)){ 
     answer = Double.parseDouble(array[i-1]) + Double.parseDouble(array[i+1]); 
    } 
} 

하지만 곱셈과 나눗셈을 감지하고 먼저를 계산하고 나머지 문자열에 결과를 추가 할 수있는 방법이 필요합니다.

Answer 1

문자열을 후위 문자 표기법으로 변환해야합니다. 여기에 대한 세부 정보 : http://en.wikipedia.org/wiki/Reverse_Polish_notation

힌트 : 운영자를 위해 스택이 필요합니다. 문자열을 구문 분석하고 피연산자를 찾을 때마다 문자열을 후행 문자열에 복사합니다. 연산자를 찾으면 우선 순위가 더 크거나 같은 모든 연산자를 스택에서 팝하고 새 문자열에 복사 한 다음 실제 연산자를 푸시합니다.

그런 다음 실제 수학을 수행해야하고 피연산자 스택을 사용해야합니다. 접미사 표기법에서 문자열을 구문 분석하는 동안 피연산자 (숫자)를 얻으면 스택에 푸시합니다. 연산자를 얻은 경우 스택의 마지막 두 요소를 가져온 다음 해당 연산자의 결과를 다시 연산자에 넣습니다.

Answer 2

내가 데모 프로그램을 만들었습니다,이 쿼리를 해결하는 데 도움이 될 것입니다 :

import java.util.Iterator; 
import java.util.LinkedList; 
import java.util.List; 

public class CalculatingString 
{ 
    public static void main(String[] args) 
    { 
     String string="2323*1212-3434+12*200/2"; 
     System.out.println("Result : "+getAnswer(string)); 
    } 

    private static List<Character> getSymbols(String string) 
    { 
     List<Character> listOfSymbols=new LinkedList<Character>(); 
     for(int i=0;i<string.length();i++) 
     { 
      char symbol=string.charAt(i); 

      if(symbol=='-' || symbol=='+' || symbol=='*' || symbol=='/') 
      { 
       listOfSymbols.add(symbol); 
      } 
     } 
     return listOfSymbols; 
    } 

    private static List<String> getOperands(String string) 
    { 
     String[] operandsArray=string.split("-|\\+|\\*|\\/"); 
     List<String> listOfOperands=new LinkedList<String>(); 

     for(int i=0;i<operandsArray.length;i++) 
      listOfOperands.add(operandsArray[i]); 

     return listOfOperands; 
    } 

    private static void listUpdater(List<Character> listOfSymbols,List<String> listOfOperands,int position,float result) 
    { 
     listOfSymbols.remove(position); 
     listOfOperands.remove(position); 
     listOfOperands.remove(position); 
     listOfOperands.add(position,String.valueOf(result)); 
     //System.out.println("==========================================================================="); 
    } 

    private static float getAnswer(String string) 
    { 
     List<Character> listOfSymbols=getSymbols(string); 
     List<String> listOfOperands=getOperands(string); 
     int operationCount=listOfSymbols.size(); 
     float operand1=0.0F; 
     float operand2=0.0F; 
     float result=0.0F; 

     while(operationCount>0) 
     { 
      if(listOfSymbols.contains('*') || listOfSymbols.contains('/')) 
      { 
       int currentPositionMultiplication=listOfSymbols.indexOf('*'); 
       int currentPositionDividation=listOfSymbols.indexOf('/'); 

       if((currentPositionMultiplication<currentPositionDividation && currentPositionMultiplication!=-1) || currentPositionDividation==-1) 
       { 
        operand1=Float.parseFloat(listOfOperands.get(currentPositionMultiplication)); 
        operand2=Float.parseFloat(listOfOperands.get(currentPositionMultiplication+1)); 
        result=operand1*operand2; 

        listUpdater(listOfSymbols,listOfOperands,currentPositionMultiplication,result); 
       } 
       else if((currentPositionMultiplication>currentPositionDividation && currentPositionDividation!=-1) || currentPositionMultiplication==-1) 
       { 
        operand1=Float.parseFloat(listOfOperands.get(currentPositionDividation)); 
        operand2=Float.parseFloat(listOfOperands.get(currentPositionDividation+1)); 
        result=operand1/operand2; 

        listUpdater(listOfSymbols,listOfOperands,currentPositionDividation,result); 
       } 

      } 
      else if(listOfSymbols.contains('-') || listOfSymbols.contains('+')) 
      { 
       int currentPositionSubstraction=listOfSymbols.indexOf('-'); 
       int currentPositionAddition=listOfSymbols.indexOf('+'); 

       if((currentPositionSubstraction<currentPositionAddition && currentPositionSubstraction!=-1) || currentPositionAddition==-1) 
       { 
        operand1=Float.parseFloat(listOfOperands.get(currentPositionSubstraction)); 
        operand2=Float.parseFloat(listOfOperands.get(currentPositionSubstraction+1)); 
        result=operand1-operand2; 

        listUpdater(listOfSymbols,listOfOperands,currentPositionSubstraction,result); 
       } 
       else if((currentPositionSubstraction>currentPositionAddition && currentPositionAddition!=-1) || currentPositionSubstraction==-1) 
       { 

        operand1=Float.parseFloat(listOfOperands.get(currentPositionAddition)); 
        operand2=Float.parseFloat(listOfOperands.get(currentPositionAddition+1)); 
        result=operand1+operand2; 

        listUpdater(listOfSymbols,listOfOperands,currentPositionAddition,result); 
       } 

      } 
      operationCount--; 
     } 

     Iterator<String> iterator=listOfOperands.iterator(); 

     String finalResult=""; 

     while(iterator.hasNext()) 
     { 
      finalResult=iterator.next(); 
     } 

     return Float.parseFloat(finalResult); 
    } 
}