java实现编写程序实现两个超长正整数（每个最长80位数字）的减法运算

问题：实现两个超长正整数（每个最长80位数字）的减法运算

【问题描述】
编写程序实现两个超长正整数（每个最长80位数字）的减法运算。
【输入形式】

从键盘读入两个整数，要考虑输入高位可能为0的情况（如00083）。

1. 第一行是超长正整数A；

2. 第二行是超长正整数B；

【输出形式】

输出只有一行，是长整数A减去长整数B的运算结果，从高到低依次输出各位数字。要求：若结果为0，则只输出一个0；否则输出的结果的最高位不能为0，并且各位数字紧密输出。

【输入样例】

234098
134098703578230056

【输出样例】

－134098703577995958

解题思路

思路：

1. 将两个超大整数用String类型存储，
2. 将超大整数前无效零，删除，再用Vector存储。
3. 对两个数进行比较，若第一个大整数大于第二个大整数，则返回1；若第一个大整数小于第二个大整数，则返回-1；若第一个大整数等于第二个大整数，则返回0
4. 模拟减法运算，此时注意，原本最后面的数字在最前面（便于处理）

代码

import java.util.Scanner;
import java.util.Vector;

public class main {
    public static void main(String [] args){
        Scanner sc = new Scanner(System.in);
        String A = sc.next();
        String B = sc.next();
        Vector<Integer> arrayA = new Vector<Integer>();
        Vector<Integer> arrayB = new Vector<Integer>();
        Vector<Integer> vectorSUB = new Vector<Integer>();
        arrayA = exceptZero(A);
        arrayB = exceptZero(B);
//        printf(arrayA);
//        System.out.println();
//        printf(arrayB);
//        System.out.println();

        if(compare(arrayA,arrayB)==0){
            System.out.println(0);
        } else if (compare(arrayA,arrayB)==1) {
            vectorSUB = SUB(arrayA,arrayB);
            printf(vectorSUB);
        }
        else if(compare(arrayA,arrayB)==-1){
            vectorSUB = SUB(arrayB,arrayA);
            System.out.print('-');
            printf(vectorSUB);
        }

    }
    //去除开始前面无效的零，并逆序存储
    public static Vector exceptZero(String a){
        Vector<Integer> number= new Vector<Integer>();
        boolean IsFirstZero = true;
        for(int i=0;i<a.length();i++){
            char ch = a.charAt(i);
            if(ch == '0' && IsFirstZero){
                continue;
            }
            else{
                IsFirstZero = false;
                number.add(0,ch - '0');
            }
        }
        return number;
    }
    //输出Vector的值
    public static void printf(Vector vector){
        boolean firstZero = true;
        for(int i=0;i<vector.size();i++){
            if((Integer)vector.get(i)==0 && firstZero){
                continue;
            }
            else{
                firstZero=false;
                System.out.print((Integer) vector.get(i));
            }

        }
    }
	// 比较第一个大整数与第二个大整数，
    //1、若第一个大整数大于第二个大整数，则返回1
    //2、若第一个大整数小于第二个大整数，则返回-1
    //3、若第一个大整数等于第二个大整数，则返回0
    public static int compare(Vector arrayA,Vector arrayB){
        if(arrayA.size()>arrayB.size()){
            return 1;
        }
        else if(arrayA.size()<arrayB.size()){
            return -1;
        }
        else{
            for (int i=arrayA.size() - 1;i >= 0;i--){
//                System.out.println(arrayA.get(i));
                if((Integer)arrayA.get(i) > (Integer) arrayB.get(i)){
                    return 1;
                }
                else if((Integer)arrayA.get(i) < (Integer) arrayB.get(i)){
                    return -1;
                }
                else{
                    continue;
                }
            }

            return 0;
        }
    }
    //进行两个大整数的减法运算，注意此时Vector的数字是逆序存储的。
    public static Vector SUB(Vector arrayFirst,Vector arraySecond){
        Vector<Integer> vectorSUB = new Vector<Integer>();
        for(int i=0;i<arrayFirst.size();i++){
            int number;
            if(i<arraySecond.size()){
                number =(Integer)arrayFirst.get(i)-(Integer) arraySecond.get(i);
            }
            else {
                number = (Integer)arrayFirst.get(i);
            }
            if (number>=0){
                vectorSUB.add(0,number);
            }
            else{
                arrayFirst.set(i+1,(Integer)arrayFirst.get(i+1)-1);
                if((Integer)arrayFirst.get(i)==0){
                    vectorSUB.add(0,10-Math.abs(number));
                }
                else{
                    vectorSUB.add(0,number+10);
                }
            }
        }
        return vectorSUB;
    }
}