Arrays 数组比较与乘法

所以我们的目标是读入两个大整数，然后加、减、乘它们回到一个40元素长的整数数组中，同时比较初始的两个整数，equalTo、notEqualTo等。我已经完成了大部分，但我仍停留在几个点上。我的isGreaterThan方法返回与它应该返回的相反的结果，例如：大整数1=100和大整数2=-100。该方法将抛出false，并表示大整数1小于大整数2。下一部分我要讲的是乘法。现在我可以将整数相乘，得到一个不超过11个元素的新整数。不知什么原因，任何更大的数字都会导致计算错误。有人建议我使用多个for循环，但我不认为这会有什么帮助。我的最后一个问题是，每当任何操作的结果等于零时，例如100+（-100），我的加法/减法/乘法方法都不会返回0。下面是我当前的代码

import java.util.Scanner;
import java.util.Arrays;

// Class that prompts the user to enter two HugeIntegers
// then compares those integers and performs addition, subtraction,
// and multiplication on those two HugeIntegers
public class HugeInteger {
    private static final int NUM_DIGITS = 40;
    private int digits[] = new int[NUM_DIGITS];
    private boolean positive;

    // Constructor
    public HugeInteger (String num){
        String parts [] = num.split(" ");
        digits = new int[parts.length];
        for(int n = 0; n < parts.length; n++) {
            digits[n] = Integer.parseInt(parts[n]);
        }
    }

    // Finds first non-zero position for first HugeInteger
    public int findFirstNonZeroPosition(){
        int position = NUM_DIGITS-1;
        for (int i = 0; i < digits.length; i++){
            if (digits[i] > 0){
                position = i;
                break;
            }
        }
        return position;
    }

    // Determines if h1 isEqualTo h2
    public boolean isEqualTo(HugeInteger hi){
        if(Arrays.equals(this.digits, hi.digits)){
            return true;
        }else {
            return false;
        }
    }

    // Determines if hi isGreaterThan h2
    public boolean isGreaterThan(HugeInteger hi){
        // different signs
        if (this.positive && (!hi.positive)){
            return true;
        }
        else if (!this.positive && hi.positive){
            return false;
        }

        // same sign
        else {

            // first number’s length is less than second number’s length
            if (findFirstNonZeroPosition() > hi.findFirstNonZeroPosition()) {
                if (positive)
                    return false;
                else
                    return true;
            }

            // first number’s length is larger than that of second number
            else if (findFirstNonZeroPosition() < hi.findFirstNonZeroPosition()) {
                if (positive)
                    return true;
                else
                    return false;
            }

            // two numbers have same length
            else {
                for (int i = 0; i < digits.length; i++ ) {
                    if ( this.digits[i] > hi.digits[i] )
                        if (positive)
                            return true;
                        else
                            return false;
                }
                if (positive)
                    return false;
                else
                    return true;
            }
        }
    }

    // Determines if h1 isNotEqualTo h2
    public boolean isNotEqualTo(HugeInteger hi){
        if(Arrays.equals(this.digits, hi.digits)){
            return false;
        }else {
            return true;
        }
    }

    // Determines if h1 isLessThan h2
    public boolean isLessThan(HugeInteger hi){
        return !(isGreaterThan(hi) || isEqualTo(hi) );
    }

    // Determines if h1 isGreaterThanOrEqualTo h2
    public boolean isGreaterThanOrEqualTo(HugeInteger hi){
        return !isLessThan(hi);
    }

    // Determines if h1 isLessThanOrEqualTo h2
    public boolean isLessThanOrEqualTo(HugeInteger hi){
        return !isGreaterThan(hi);
    }

    // instance variables are digits, NUM_DIGITS, positive
    // addArrayDigits and subtractArrayDigits
    // Determines how to add h1 and h2
    public void add(HugeInteger hi){
        if(positive!=hi.positive){
            if(this.positive){
                // "this" is positive, hi is negative
                hi.negate(); // negate hi temporarily

                if(this.isGreaterThan(hi)){
                    // |this| > |hi|
                    this.digits = subtractArrayDigits(this.digits, hi.digits);
                }else{
                    // |this| <= |hi|
                    this.digits = subtractArrayDigits(hi.digits, this.digits);
                    // negate the "this"
                    negate();
                }
                hi.negate(); // restore hi's sign
            }else{
                // "this" is negative, hi is positive

            }
        }else{
            // same sign :)
            digits = addArrayDigits(this.digits, hi.digits);
        }
    }

    // instance variables are digits, NUM_DIGITS, positive
    // addArrayDigits and subtractArrayDigits
    // Determines how to subtract h1 and h2
    public void subtract(HugeInteger hi){
        if(positive!=hi.positive){
            if(this.positive){
                // "this" is positive, hi is negative
                hi.negate(); // negate hi temporarily

                if(this.isGreaterThan(hi)){
                    // |this| > |hi|
                    this.digits = addArrayDigits(this.digits, hi.digits);
                }else{
                    // |this| <= |hi|
                    this.digits = addArrayDigits(hi.digits, this.digits);
                    // negate the "this"
                    negate();
                }
                hi.negate(); // restore hi's sign
            }else{
                // "this" is negative, hi is positive
            }
        }else{
            // same sign :)
            digits = subtractArrayDigits(this.digits, hi.digits);
        }
    }

    // Multiplies h1 and h2
    public void multiply(HugeInteger hi){
        for (int i = 0; i < digits.length; ++i) {
            digits[i] = this.digits[i] * hi.digits[i];
        }
    }

    // Flips the sign
    public void negate(){
        positive =! positive;
    }

    // Determines if an element is zero
    public boolean isZero(){
        for(int i = 0; i < digits.length; i++)
        if(digits[i]!= 0)
            return false;
        return true;
    }

    // Puts HugeInteger into a String in LSD format
    public String toString() {
        String str = "";
        int i;
        for(i = digits.length -1; i >= 0; i--) {
            if(digits[i] != 0)
            break;
        }
        for(int j = i; j >= 0; j--) {
            str = digits[j] + str;
        }
        return str;
    }

    // Subtracts h2 from h1
    private static int[] subtractArrayDigits(int[] array1, int[] array2){
        for (int i = 0; i < array1.length; ++i) {
            array1[i] = array1[i] - array2[i];
        }
        return array1;
    }

    // Adds h2 to h1
    private static int[] addArrayDigits(int[] array1, int[] array2){
        //int i = 0;
        for (int i = 0; i < array1.length; ++i) {
            array1[i] = array1[i] + array2[i];
        }
        return array1;
    }

    // Main method
    public static void main(String args[]){
        HugeInteger h1, h2;
        String num;
        Scanner scan=new Scanner(System.in);

        System.out.print("Please enter the first huge integer (h1): ");
        num=scan.nextLine();
        h1=new HugeInteger(num);

        System.out.print("Please enter the second huge integer (h2): ");
        num=scan.nextLine();
        h2=new HugeInteger(num);

        if(h1.isEqualTo(h2)){
            System.out.println("h1 is equal to h2.");
        }
        if(h1.isNotEqualTo(h2)){
            System.out.println("h1 is not equal to h2.");
        }
        if(h1.isGreaterThan(h2)){
            System.out.println("h1 is greater than h2.");
        }
        if(h1.isLessThan(h2)){
            System.out.println("h1 is less than to h2.");
        }
        if(h1.isGreaterThanOrEqualTo(h2)){
            System.out.println("h1 is greater than or equal to h2.");
        }
        if(h1.isLessThanOrEqualTo(h2)){
            System.out.println("h1 is less than or equal to h2.");
        }

        h1.add(h2);
        System.out.printf("h1 + h2 = %s\n",h1);
        h1.subtract(h2);
        h1.subtract(h2);
        System.out.printf("h1 - h2 = %s\n",h1);
        h1.add(h2);
        h1.multiply(h2);
        System.out.printf("h1 * h2 = %s\n",h1);
    }
}

import java.util.Scanner；
导入java.util.array；
//类，该类提示用户输入两个HugeInteger
//然后比较这些整数并执行加法、减法、，
//和那两个巨人的乘法运算
公共类HugeInteger{
专用静态最终整数位数=40；
私有整数位数[]=新整数位数[]；
私有布尔正；
//建造师
公共HugeInteger（字符串数）{
字符串部分[]=num.split（“”）；
数字=新整数[零件长度]；
对于（int n=0；n0）{
位置=i；
打破
}
}
返回位置；
}
//确定h1是否等于h2
公共布尔isEqualTo（HugeInteger hi）{
if（数组.equals（this.digits，hi.digits））{
返回true；
}否则{
返回false；
}
}
//确定hi是否大于h2
公共布尔值大于（HugeInteger hi）{
//不同的标志
如果（这是正的&（！hi.positive））{
返回true；
}
否则如果（！this.positive&&hi.positive）{
返回false；
}
//同一符号
否则{
//第一个数字的长度小于第二个数字的长度
如果（findFirstNonZeroPosition（）>hi.findFirstNonZeroPosition（））{
如果（正）
返回false；
其他的
返回true；
}
//第一个数的长度大于第二个数的长度
else if（findfirstnonzeropposition（）hi.digits[i]）
如果（正）
返回true；
其他的
返回false；
}
如果（正）
返回false；
其他的
返回true；
}
}
}
//确定h1是否为NOTEQUALTO h2
公共布尔值isNotEqualTo（HugeInteger hi）{
if（数组.equals（this.digits，hi.digits））{
返回false；
}否则{
返回true；
}
}
//确定h1是否小于h2
公共布尔值小于（HugeInteger hi）{
返回！（比（嗨）| | isEqualTo（嗨））；
}
//确定h1是否大于或等于h2
公共布尔值大于或等于（HugeInteger hi）{
返回！isLessThan（hi）；
}
//确定h1是否小于或等于h2
公共布尔isLessThanOrEqualTo（HugeInteger hi）{
返回！大于（hi）；
}
//实例变量为数字、NUM_数字、正数
//addArrayDigits和subtractArrayDigits
//确定如何添加h1和h2
公共空白添加（HugeInteger hi）{
如果（正的！=高正的）{
如果（这是肯定的）{
//“this”为正，hi为负
hi.negate（）；//暂时否定hi
如果（此值大于（hi））{
//|这|>|嗨|
this.digits=减法数组数字（this.digits，hi.digits）；
}否则{
//|这|=0；我--）{
如果（数字[i]！=0）
打破
}
对于（int j=i；j>=0；j--）{
str=数字[j]+str；
}
返回str；
}
//从h1中减去h2
私有静态int[]减去数组数字（int[]数组1，int[]数组2）{
对于（int i=0；i