문자열 구문 분석 및 빼기 연산자 (BIgInterge를 사용하지 않음)의 방법은, 문제는 나를보고 도움

덧셈과 뺄셈 오늘의 문자열을 쓰기 방법 (BIgInterge를 사용하지 않는) 문제는 당신이 날 문제가 있는지 여부를 확인하는 데 도움 :

공용  클래스 StringCalculator {
     공공  정적  무효 메인 (문자열 []에 args) {
         // 테스트 
        에서 System.out.println (parseStrAri ( "99 + 99 + 99 + 1 =." )); 
    } 

    // 파싱 감산 
    개인  정적 parseStrAri 문자열 (문자열 신지) {
         // 연산자 어레이 
        | - [] = (이하 "= \\ +"는 nums를 dest.split 문자열 )
         // 산술 기호 
        문자 [] = dest.replaceAll의 OPS ( "[0-9] "," " ) .toCharArray ();
         // 매개 변수를 확인 
        IF (nums.length == 0 || ops.length == 0 ) {
             던져  새로운 새로운는 IllegalArgumentException ( "표현에 부합하지 않는 잘못된 입력 매개 변수" ); 
        } 
        INT numIndex = 0 ; 
        문자열 결과 = nums [0 ]
         에 대한 ( 문자의 C : OPS) {
             스위치 (C) {
                 케이스 '+' :
                     // - 결과에 따른 B + - (AB) 20,000 처리 -1000+ 
                    경우 ( "-"등호 (result.substring (0,1. ))) { 
                        문자열 NUMA =   EXPUNGE (결과); 
                        문자열 NUMB = nums [++ numIndex];
                         IF (isLeftBig (NUMA 마비)) {
                            결과 = subtractionStr NUMA (마비); 
                            결과 = "-"+ 결과; 
                        } 다른 { 
                            결과 = subtractionStr (마비, NUMA); 
                        } 
                    } 또 { 
                        결과 = additionStr (결과 nums [++ numIndex]); 
                    } 
                    휴식 ;
                경우 '-' : 
                    문자열 마비 =의 nums [++ numIndex]
                    만약(. "-이"동일 (result.substring (0,1 ))) { 
                        문자열 NUMA = 적인 삭제 (결과); 
                        결과 = additionStr NUMA (마비); 
                        결과 = "-"+ 결과; 
                    } 다른 { 
                        문자열 NUMA = 결과;
                        경우 (isLeftBig NUMA (마비)) { 
                            결과 = subtractionStr NUMA (마비); 
                        } 다른 { 
                            결과 = subtractionStr (마비, NUMA); 
                            결과= "-"+ 결과; 
                        } 
                    } 
                    휴식 ;
                케이스 '=' :
                     리턴 결과; // 这里返回结果
                기본 :
                     // 무시 
            } 
        } 

        반환 결과; 
    } 

    // 추가加法
    개인  정적 문자열 additionStr (문자열 A, 문자열 B)를 { 
        의 StringBuilder 빌더 = 새 의 StringBuilder를 (); =  역방향 (a);
        B = 역방향 (b);
        // 调换
        경우 (a.length () < b.length를 ()) { 
            문자열 C = B; 
            B = a 및 =의 C; 
        } 
        INT 알렌은 = () a.length 단계;
        INT BLEN = b.length를 (); 

        부울 ISOVER = 거짓 ;
        위한 ( int로 I = 0; I는를 <알렌; 나는 ++ ) {
             INT의 결과 = 0 ;
            INT 체인지 = a.charAt (I) - (48) ;
            있는 경우 는 (i < BLEN)을 {
                 {INT 샤 르브 = b.charAt (I) - (48) ; 
                결과 = 체인지 + 샤 르브; 
            } 다른 { 
                결과 = + 결과 체인지; 
            } 
            // 进位
            경우 (ISOVER) { 
                결과 ++ ; 
            } 
            경우 (결과> = 10 ) { 
                builder.append (결과 - 10 ); 
                ISOVER = 진정한 ; 
            } 다른 
                builder.append (결과); 
                ISOVER = 거짓 ; 
            } 
        } 
        경우 (ISOVER) { 
            builder.append ( "1" ); 
        } 
        리턴 역방향 (builder.toString ()); 
    } 

    // 서브减法
    개인  정적 문자열 subtractionStr (문자열 A, 문자열 b) { 
        의 StringBuilder 빌더 = 새 의 StringBuilder (); = 역방향 (a); 
        B = 역방향 (b);
        // 调换
        경우 (a.length () < b.length를 ()) {
             던져  새로운 , IllegalArgumentException를 ( "字符串有误"); 
        } 

        INT 알렌은 = () a.length 단계;
        INT BLEN = b.length를 ();
        바이트 ISOVER = 0; //   借位을 

        위해 ( int로 ; 나는 알렌 <I ++는 I = 0 ) {
             INT의 결과 = 0 ;
            INT 체인지 = a.charAt (I) - (48) ; 
            결과 결과 = + ISOVER; 
            ISOVER = 0 ;
            있는 경우 는 (i < BLEN)을 {
                 INT 샤 르브 = b.charAt (I) - (48) 결과 = +; 
                결과 ) {체인지;
                경우 (결과 <0 ) { 
                    결과 + = 10 ; 
                    ISOVER - ; 
                } 
                결과 = 결과 - 샤 르브;
                경우 (결과 <0 ) { 
                    결과 + = 10 ; 
                    ISOVER - ; 
                } 
            } 또 { 
                결과 = + 체인지의 결과;
                경우 (결과 <0 
                    결과 + = 10; 
                    ISOVER - ; 
                } 
            } 
            builder.append (결과); 
        } 
        리턴 expungeZero은 (후진 (builder.toString ())); 
    } 

    // 反序
    개인  정적 문자열 역방향 (문자열 값) {
         경우 (값 == 널 || value.length () <= 1 ) {
             리턴 값; 
        } 
        리턴 역방향 (value.substring (1)) + value.charAt (0 ); 
    } 

    // 取零的前缀
    개인  정적 문자열 expungeZero (문자열들) {
         복귀 ( "^ 0 *", ""을 s.replaceFirst ); 
    } 

    개인  정적 문자열적인 삭제가 (문자열들) {
         반환 s.replaceFirst를 ( "^ - *", "" ); 
    } 

    개인  정적  부울 isLeftBig (문자열 A, 문자열 b) {
         경우 (a.length () == b.length를 ()) {
             반환 a.compareTo (b)> 0 ; 
        } 
        경우 (a.length ()> b.length를 ()) {
             반환  사실 ; 
        } 
        반환  거짓 ; 
    } 

}