大数据类型的计算

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/***
 * 表示大数据类型
 * @author lujintao
 *
 */
public class BigNumber{
    //BASE指的是进制基数，好比2进制，16进制
    private static final int BASE = 10;
    private static final int LENGTH = new Integer(BASE).toString().length() - 1;
    //依次存放从低位到高位的数值
    private List<Integer> data_list = new ArrayList<Integer>();

    /**
     *
     * @param number 为一数字字符串，如 "39939399399392993939939299292992929299292999"
     */
    public BigNumber(String number){
        //校验数据有效性部分省略
        if(Pattern.matches("^\\d+$", number)){
            //获取字符串长度
            int length = number.length();
            //我们按每四个字符一组对number_inverse字符串从右至左进行分割，count存放的是分割后字符组的个数
            int count = 0;
            //记录分割后左边的第一个字符串的长度
            int first_length = 0;
            if(length % LENGTH != 0){
                count = length / LENGTH + 1;
                first_length = length % LENGTH;
            }else{
                count = length / LENGTH;
                first_length = LENGTH;
            }
           
            for(int i = 0; i < count; i++){
                String temp = "0";
                if(i == count - 1){
                    temp = number.substring(0, first_length);
                }else{
                    temp = number.substring(length - (i + 1) * LENGTH, length - i * LENGTH);
                }
                data_list.add(Integer.parseInt(temp));
            }
        }else{
            throw new IllegalArgumentException("输入的参数非法,参数中只能包含数字");
        }
    }
   
    public BigNumber(List<Integer> data_list){
        this.data_list = data_list;
    }
   
    /**
     * 求与另一个BigNumber类型的数据相加之后的结果
     * @param another_number
     * @return
     */
    public BigNumber plus(BigNumber another_number){
        BigNumber result = null;
        if(another_number != null){
            //按从低位到高位存放计算结果
            List<Integer> list = new ArrayList<Integer>();
            //同位相加后要进位的数值
            int over_number = 0;
            //计算出要循环的次数
            int count = (this.size() > another_number.size()) ? this.size() : another_number.size();
           
            for(int i = 0; i < count; i++){
                //当前大数据 参与同位运算的数据项
                int one_item = ((this.size() -1) >= i) ? this.data_list.get(i) : 0;
                //另一大数据 参与同位运算的数据项
                int another_item = ((another_number.size() -1) >= i) ? another_number.data_list.get(i) : 0;
                int sum = one_item + another_item + over_number;
                over_number = sum / BASE;
                //余数为该位上相加后应保留的结果
                list.add(sum % BASE);
            }
            if(over_number > 0){
                list.add(over_number);
            }
            result = new BigNumber(list);
        }else{
            throw new IllegalArgumentException("参数不能为空");
        }
        return result;
    }
   
    public List<Integer> getData_list() {
        return data_list;
    }
   
    /**
     * 获得以BASE为基数，数的位数
     * @return
     */
    public  int size(){
        return this.data_list.size();
    }

    /**
     * 返回大数据类型的字符串表示，最高位从最左边开始输出
     */
    public String toString(){
        StringBuilder builder = new StringBuilder();
        for(int i = data_list.size() - 1; i >= 0 ; i--){
            builder.append(format(data_list.get(i)));
        }
        return builder.toString();
    }
   
    /**
     * 返回一个整数对应的长度为LENGTH的字符串,如 LENGTH 为4时，55返回的字符串为 0055
     * @param number
     * @return
     */
    private String format(Integer number){
        StringBuilder result = new StringBuilder();
        if(number.toString().length() <= LENGTH){
            for(int i = 0; i < LENGTH - number.toString().length(); i++){
                result.append("0");
            }
        }else{
            throw new IllegalArgumentException("输入的整数过大");
        }
        result.append(number);
        return result.toString();
    }
   
    public static void main(String[] args){
        BigNumber one = new BigNumber("123456789123456789123456789");
        BigNumber another = new BigNumber("876543210876543210876543210876543210876543210876543210");
        System.out.println(one.plus(another));
    }
}