Java I'；m试图对大于任何可用数据类型大小的数字执行整数除法

就大数字而言，我知道java BigInteger中有一个可用的类，但我有一个限制，我不能使用它，我必须在不使用库的情况下执行除法

这是我到目前为止尝试过的，但是内存泄漏问题并没有得到任何答案

private Integer getDivisionResult(ArrayList<Integer> first, ArrayList<Integer> second) {
    int firstLength = first.size();
    int secondLength = second.size();
    int counter = 0;
    if (firstLength < secondLength) {
        return counter;
    }
    do {
        int carry = 0, cursor1 = firstLength - 1, cursor2 = secondLength - 1;
        for (int i = firstLength - 1; i >= 0; i--, cursor1--, secondLength--) {
            int value = 0, from = 0;
            from = first.get(cursor1) - carry;
            if (from < (cursor2 < 0 ? 0 : second.get(cursor2))) {
                if (cursor1 > 0) {
                    from = 10 + from;
                }
                carry = 1;
            } else {
                carry = 0;
            }
            value = from - (cursor2 < 0 ? 0 : second.get(cursor2));
            first.set(i, value);
        }
        counter++;
    }while (isLesserThan(second,first));
    return counter;
}


private boolean isLesserThan(ArrayList<Integer> list, ArrayList<Integer> firstList) {
    boolean result = true;
    if (list.size() < firstList.size()) {
        return true;
    }
    for (int i = 0; i < list.size(); i++) {
        if (firstList.get(i) > list.get(i)) {
            result = true;
            break;
        } else if (firstList.get(i) == list.get(i)) {
            continue;
        } else {
            result = false;
            break;
        }
    }
    return result;
}

私有整数getDivisionResult（ArrayList第一，ArrayList第二）{
int firstLength=first.size（）；
int secondLength=second.size（）；
int计数器=0；
如果（第一个长度<第二个长度）{
返回计数器；
}
做{
int进位=0，游标1=firstLength-1，游标2=secondLength-1；
对于（int i=firstLength-1；i>=0；i--，cursor1--，secondLength--）{
int值=0，from=0；
from=first.get（cursor1）-进位；
if（从<（游标2<0？0：秒。获取（游标2）））{
如果（游标1>0）{
from=10+from；
}
进位=1；
}否则{
进位=0；
}
值=from-（cursor2<0？0:second.get（cursor2））；
首先，设置（i，值）；
}
计数器++；
}而(伊斯莱瑟坦(第二,第一)),；
返回计数器；
}
私有布尔isLesserThan（ArrayList列表，ArrayList firstList）{
布尔结果=真；
if（list.size（）list.get（i））{
结果=真；
打破
}else if（firstList.get（i）=list.get（i））{
继续；
}否则{
结果=假；
打破
}
}
返回结果；
}

在通过某些错误案例后，我在此方法内调用getDivisionResult：

 /**
 * @param numOne
 * @param numTwo
 * @return sign : true (negative) , false (positive)
 */
public Result getResult(String numOne, String numTwo) {
    Result result = new Result();
    int res = 0;
    boolean sign = false;
    ArrayList<Integer> firstNum;
    ArrayList<Integer> secondNum;
    if (isNegative(numOne)) {
        firstNum = getArray(numOne.substring(1));
        if (isNegative(numTwo)) {
            sign = false;
            secondNum = getArray(numTwo.substring(1));
        } else {
            secondNum = getArray(numTwo);
            sign = true;
        }
    } else {
        firstNum = getArray(numOne);
        if (isNegative(numTwo)) {
            sign = true;
            secondNum = getArray(numTwo.substring(1));
        } else {
            secondNum = getArray(numTwo);
        }
    }
    if (isNull(secondNum)) {
        result.setSign("Division by 0 is not permissable");
        result.setValue(res);
        return result;
    } else {
        if (isNull(firstNum)) {
            result.setSign("");
            result.setValue(res);
            return result;
        }
        firstNum = getNumberWithoutZeroes(firstNum);
        secondNum = getNumberWithoutZeroes(secondNum);
        res = getDivisionResult(firstNum, secondNum);
        if (sign) {
            result.setSign("-");
        } else {
            result.setSign("");
        }
        result.setValue(res);
    }
    return result;
}

private ArrayList<Integer> getNumberWithoutZeroes(ArrayList<Integer> num) {
    ArrayList<Integer> list = new ArrayList<>();
    for (Integer x : num) {
        if (x == 0) {
            continue;
        } else {
            list.add(x);
        }
    }
    return list;
}

private boolean isNegative(String num) {
    boolean result = false;
    if (num.startsWith("-")) {
        result = true;
    }
    return result;
}

private boolean isNull(ArrayList<Integer> num) {
    boolean result = true;
    for (Integer x : num) {
        if (x > 0) {
            result = false;
        }
    }
    return result;
}

private ArrayList<Integer> getArray(String num) {
    ArrayList<Integer> list = new ArrayList<>();
    char[] arr = num.toCharArray();
    for (int i = 0; i < num.length(); i++) {
        list.add(Integer.valueOf(arr[i]));
    }
    return list;
}

/**
*@param numOne
*@param numTwo
*@返回符号：真（负）、假（正）
*/
公共结果getResult（字符串numOne，字符串numTwo）{
结果=新结果（）；
int res=0；
布尔符号=假；
ArrayList firstNum；
arraylistsecondnum；
如果（是负数（努蒙））{
firstNum=getArray（numOne.substring（1））；
如果（为负（numTwo））{
符号=假；
secondNum=getArray（numtw.substring（1））；
}否则{
secondNum=getArray（numTwo）；
符号=真；
}
}否则{
firstNum=getArray（numOne）；
如果（为负（numTwo））{
符号=真；
secondNum=getArray（numtw.substring（1））；
}否则{
secondNum=getArray（numTwo）；
}
}
if（isNull（secondNum））{
结果.setSign（“不允许除以0”）；
结果：设定值（res）；
返回结果；
}否则{
if（isNull（firstNum））{
结果：设置符号（“”）；
结果：设定值（res）；
返回结果；
}
firstNum=getnumberwhithoutzeries（firstNum）；
secondNum=getnumberwhithoutzero（secondNum）；
res=getDivisionResult（firstNum，secondNum）；
如果（签名）{
结果：设置符号（“-”）；
}否则{
结果：设置符号（“”）；
}
结果：设定值（res）；
}
返回结果；
}
私有ArrayList getNumberWithoutZeroes（ArrayList num）{
ArrayList=新建ArrayList（）；
for（整数x:num）{
如果（x==0）{
继续；
}否则{
增加（x）；
}
}
退货清单；
}
私有布尔值为负（字符串数）{
布尔结果=假；
if（num.startsWith（“-”）{
结果=真；
}
返回结果；
}
私有布尔值为空（ArrayList num）{
布尔结果=真；
for（整数x:num）{
如果（x>0）{
结果=假；
}
}
返回结果；
}
私有ArrayList getArray（字符串num）{
ArrayList=新建ArrayList（）；
char[]arr=num.toCharArray（）；
对于（int i=0；i

---

如果有人能帮助我更好地解决我的问题，我将不胜感激。

我已经解决了我自己的问题，但现在的问题是它的处理速度。

“我有一个限制…”所以这一定是学校的一个特殊挑战项目，而你基本上是在试图作弊。我认为没有其他理由不让您使用JDKI中已经内置的完美解决方案，我投票将这个问题作为离题来结束，因为这个问题几乎肯定是编程类中的一个挑战，要复制Java中已经存在的功能。我想知道的是，是否存在更好的解决方案，或者不rest是你想怎么做就怎么做。要求更好的解决方案的问题也是离题的，因为这类问题的答案几乎都是基于意见的。这里有很多很棒的在线资源，展示了如何除数。尝试查找文件

divmnu.c

以获取帮助。它使用Knuth的方法。好吧，这不是Java，但很容易阅读。