10的千次方级大数与1~10000的数之间进行求mod（java）

大数采用集合的方式存储

	public ArrayList<Integer> aNumber;
	public ArrayList<Integer> bNumber;

随机生成一个大数存储

	public static ArrayList<Integer> randomNumber(Integer length) {
        ArrayList arrayList = new ArrayList();
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            arrayList.add(random.nextInt(10));
        }
        removeZero(arrayList);
        return arrayList;
    }

清除首部0的方法removeZero

	//减去集合首部多余的0  例如[0,0,1,3,2]=>[1,3,2]
	public static ArrayList<Integer> removeZero(ArrayList<Integer> arrayList) {   
        while (true) {
            if (arrayList.get(0) != 0) {    //判断集合首部是否有0
                break;
            }else{
                arrayList.remove(0);  //删除集合首部的元素
            }
        }
        return arrayList;
    }

将集合索引前五位的元素解析成整数

//将aNumber集合索引0~5的元素解析成一个10进制的整数，存储到sumA中
        if (this.aNumber.size() > 5) {
            for (int i = 4; i >= 0; i--) {
                sumA = sumA + (int)(this.aNumber.remove(0) * Math.pow(10, i));
            }
        } else {
            while (!this.aNumber.isEmpty()) {
                sumA = sumA + (int) (this.aNumber.remove(0) * Math.pow(10, this.aNumber.size()));
            }
        }

//将集合索引0~5的元素解析成一个10进制的整数，存储到sumB中
        temporary = new ArrayList<>(bNumber);
        if (this.temporary.size() > 4) {
            System.out.println("求mod异常");
            return -1;
        } else {
            while (!this.temporary.isEmpty()) {
                sumB = sumB + (int) (this.temporary.remove(0) * Math.pow(10, this.temporary.size()));
            }
        }

求mod

第一次求mod

	try {
            result = sumA % sumB;
        }catch (ArithmeticException e){
            System.out.println(e);
        }

对集合进行非空判断，不为空将得到的mod添加到集合首部，递归本方法

 		//如果aNumber集合不为空，将result添加至aNumber集合的首部
        if (!this.aNumber.isEmpty()){
            //将result添加至aNumber集合的首部
            for (int i = 1;i<=result.toString().length();i++){
                aNumber.add(0,(int)(result/Math.pow(10,i-1)%10));
            }
            result = mod();  //递归调用
        }

结果测试

第一次测试

public static void main(String[] args) {
        Number number = new Number(Number.randomNumber(10),Number.randomNumber(4));
        System.out.println(number.getaNumber());
        System.out.println(number.getbNumber());
        System.out.print("mod:");
        System.out.println(number.mod());

    }

结果正常

第二次测试

public static void main(String[] args) {
        Number number = new Number(Number.randomNumber(30),Number.randomNumber(4));
        System.out.println(number.getaNumber());
        System.out.println(number.getbNumber());
        System.out.print("mod:");
        System.out.println(number.mod());
    }

结果正常

最后测试

public static void main(String[] args) {
        Number number = new Number(Number.randomNumber(1000),Number.randomNumber(4));
        System.out.println(number.getaNumber());
        System.out.println(number.getbNumber());
        System.out.print("mod:");
        System.out.println(number.mod());
    }

暂无法对结果进行验证

完整的Number类代码

package study.hard.one.demo12;

import java.util.*;

public class Number {
    public ArrayList<Integer> aNumber;
    public ArrayList<Integer> bNumber;
    public ArrayList<Integer> temporary;

    public Number() {
    }

    public Number(String aNumber, String bNumber) {
        this.aNumber = new ArrayList<>();
        this.bNumber = new ArrayList<>();
        for (Character c : aNumber.toCharArray()) {
            if (Character.isDigit(c)) {
                this.aNumber.add((int) (c - '0'));
            }
        }
        for (Character c : bNumber.toCharArray()) {
            if (Character.isDigit(c)) {
                this.bNumber.add((int) (c - '0'));
            }
        }
        this.temporary = new ArrayList<>(this.bNumber);
    }

    public Number(ArrayList<Integer> aNumber, ArrayList<Integer> bNumber) {
        this.aNumber = aNumber;
        this.bNumber = bNumber;
        this.temporary = new ArrayList<>(bNumber);
    }

    public Number(ArrayList<Integer> aNumber, ArrayList<Integer> bNumber, ArrayList<Integer> temporary) {
        this.aNumber = aNumber;
        this.bNumber = bNumber;
        this.temporary = temporary;
    }

    public ArrayList<Integer> getaNumber() {
        return aNumber;
    }

    public void setaNumber(ArrayList<Integer> aNumber) {
        this.aNumber = aNumber;
    }

    public ArrayList<Integer> getbNumber() {
        return bNumber;
    }

    public void setbNumber(ArrayList<Integer> bNumber) {
        this.bNumber = bNumber;
    }

    public ArrayList<Integer> getTemporary() {
        return temporary;
    }

    public void setTemporary(ArrayList<Integer> temporary) {
        this.temporary = temporary;
    }

    public static ArrayList<Integer> randomNumber(Integer length) {
        ArrayList arrayList = new ArrayList();
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            arrayList.add(random.nextInt(10));
        }
        removeZero(arrayList);
        return arrayList;
    }

    public static ArrayList<Integer> removeZero(ArrayList<Integer> arrayList) {   //减去集合首部多余的0  例如[0,0,1,3,2]=>[1,3,2]
        while (true) {
            if (arrayList.get(0) != 0) {    //判断集合首部是否有0
                break;
            }else{
                arrayList.remove(0);  //删除集合首部的元素
            }
        }
        return arrayList;
    }

    public Integer mod() {           //求mod运算
        Integer result = null;
        Integer sumA = 0;
        Integer sumB = 0;

        //将aNumber集合索引0~5的元素解析成一个10进制的整数，存储到sumA中
        if (this.aNumber.size() > 5) {
            for (int i = 4; i >= 0; i--) {
                sumA = sumA + (int)(this.aNumber.remove(0) * Math.pow(10, i));
            }
        } else {
            while (!this.aNumber.isEmpty()) {
                sumA = sumA + (int) (this.aNumber.remove(0) * Math.pow(10, this.aNumber.size()));
            }
        }

        //将集合索引0~5的元素解析成一个10进制的整数，存储到sumB中
        temporary = new ArrayList<>(bNumber);
        if (this.temporary.size() > 4) {
            System.out.println("求mod异常");
            return -1;
        } else {
            while (!this.temporary.isEmpty()) {
                sumB = sumB + (int) (this.temporary.remove(0) * Math.pow(10, this.temporary.size()));
            }
        }
        temporary = null;

        //求mod，将结果储存到result中
        try {
            result = sumA % sumB;
        }catch (ArithmeticException e){
            System.out.println(e);
        }

        //如果aNumber集合不为空，将result添加至aNumber集合的首部
        if (!this.aNumber.isEmpty()){
            for (int i = 1;i<=result.toString().length();i++){          //将result添加至aNumber集合的首部
                aNumber.add(0,(int)(result/Math.pow(10,i-1)%10));
            }
            result = mod();  //递归调用
        }

        return result;
    }
}