MyException - 我的异常网
当前位置:我的异常网» 数据结构与算法 » java实现硕大无比整数加减乘除四则运算

java实现硕大无比整数加减乘除四则运算

www.MyException.Cn  网友分享于:2013-10-27  浏览:0次
java实现超大整数加减乘除四则运算

原理:

用数组存储数字,按照计算法则进行运算。

 

代码:

package com.hdwang;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 大数四则运算(超出long型的大数(64位:18446744073709551615))
 * Created by hdwang on 2017/10/9.
 */
public class Calculator {

    /**
     * 两数相加
     * @param numStr1 数1
     * @param numStr2 数2
     * @return 结果
     */
    public static String add(String numStr1, String numStr2){

        int numLen1 = numStr1.length();
        int numLen2 = numStr2.length();

        int[] numArray1 = new int[numLen1]; //数字数组
        int[] numArray2 = new int[numLen2];



        // "12345"-> [5,4,3,2,1]
        for(int i=0;i<numLen1;i++){
            String c = numStr1.substring(i,i+1);
            numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }
        for(int i=0;i<numLen2;i++){
            String c = numStr2.substring(i,i+1);
            numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }


        int minLen = 0; //取长度小的数位数
        int maxLen = 0; //取长度大的数位数
        int[] maxArray = null; //长度大的数
        if(numLen1<numLen2){
            minLen = numLen1;
            maxLen = numLen2;
            maxArray = numArray2;
        }else{
            minLen = numLen2;
            maxLen = numLen1;
            maxArray = numArray1;
        }

        int[] resultArray = new int[maxLen+1]; //考虑到可能会进位,多给一个元素空间

        //两数长度相同的部分,同位相加,超出9进1
        int added = 0;
        int i=0;
        for(;i<minLen;i++){
            int t = numArray1[i]+numArray2[i]+added; //两数相加,再加进位
            if(t>9){
                added = 1; //进1
                resultArray[i] = t-10; //当前位计算结果
            }else{
                added = 0; //不进位
                resultArray[i] = t; //当前位计算结果
            }
        }
        //长度超出部分累加
        for(;i<maxLen;i++){
            int t = maxArray[i]+added; //多余位数加上进位
            if(t>9){
                added = 1; //进1
                resultArray[i] = t-10; //当前位计算结果
            }else{
                added = 0; //不进位
                resultArray[i] = t; //当前位计算结果
            }
        }
        resultArray[i] = added; //最高位

        //拼接结果 [1,4,8,2,0] -> 2841
        StringBuilder builder = new StringBuilder();
        for(int n=resultArray.length-1;n>=0;n--){
            //如果最高位为0,移除
            if(n==resultArray.length-1 && resultArray[resultArray.length-1]==0){
                continue; //跳过
            }else{
                builder.append(resultArray[n]);
            }
        }

        return builder.toString();
    }

    /**
     * 两数相减
     * @param numStr1 数1
     * @param numStr2 数2
     * @return 结果
     */
    public static String subtract(String numStr1,String numStr2){
        int numLen1 = numStr1.length();
        int numLen2 = numStr2.length();

        int[] numArray1 = new int[numLen1]; //数字数组
        int[] numArray2 = new int[numLen2];



        // "12345"-> [5,4,3,2,1]
        for(int i=0;i<numLen1;i++){
            String c = numStr1.substring(i,i+1);
            numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }
        for(int i=0;i<numLen2;i++){
            String c = numStr2.substring(i,i+1);
            numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }


        int minLen = 0; //取长度小的数位数
        int maxLen = 0; //取长度大的数位数
        int[] maxArray = null; //数值大的数
        if(numLen1<numLen2){
            minLen = numLen1;
            maxLen = numLen2;
            maxArray = numArray2;
        }else{
            minLen = numLen2;
            maxLen = numLen1;
            maxArray = numArray1;
            if(numLen1 == numLen2){ //等于
                maxArray = getMaxNumber(numArray1,numArray2);
            }
        }
        int[] minArray = maxArray==numArray1?numArray2:numArray1; //数值小的数

        int[] resultArray = new int[maxLen];

        //大数-小数,同位相减,小于0借位
        int subtracted = 0;
        int i=0;
        for(;i<minLen;i++){
            int t = maxArray[i] - minArray[i] - subtracted; //两数相减,再减借位
            if(t<0){
                subtracted = 1; //向高位借1,暂存起来
                resultArray[i] = t+10; //当前位计算结果(借1相当于借了10)
            }else{
                subtracted = 0; //不借位
                resultArray[i] = t; //当前位计算结果
            }
        }
        //大数超出部分减掉借位
        for(;i<maxLen;i++){
            int t = maxArray[i]-subtracted; //多余位数减掉借位
            if(t<0){
                subtracted = 1; //进1
                resultArray[i] = t+10; //当前位计算结果
            }else{
                subtracted = 0; //不借位
                resultArray[i] = t; //当前位计算结果
            }
        }

        //拼接结果 [1,4,8,2,0] -> 2841
        StringBuilder builder = new StringBuilder();
        boolean highBitNotEqualZero = false; //存在高位不为0的情况,低位0保留
        for(int n=resultArray.length-1;n>=0;n--){
            //如果高位为0,移除
            if(resultArray[n]==0 && !highBitNotEqualZero && n!=0){ //高位无用的0去除
                continue; //跳过
            }else{
                highBitNotEqualZero = true; //找到不为0的位
                builder.append(resultArray[n]);
            }
        }

        if(maxArray == numArray1){ //第一个数大或相等

        }else{  //第一个数小于第二个数,相减为负数
            builder.insert(0,"-");
        }

        return builder.toString();
    }

    /**
     * 两数相乘
     * @param numStr1 数1
     * @param numStr2 数2
     * @return 结果
     */
    public static String multiply(String numStr1,String numStr2){
        int numLen1 = numStr1.length();
        int numLen2 = numStr2.length();

        int[] numArray1 = new int[numLen1]; //数字数组
        int[] numArray2 = new int[numLen2];



        // "12345"-> [5,4,3,2,1]
        for(int i=0;i<numLen1;i++){
            String c = numStr1.substring(i,i+1);
            numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }
        for(int i=0;i<numLen2;i++){
            String c = numStr2.substring(i,i+1);
            numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }


        int minLen = 0; //取长度小的数位数
        int maxLen = 0; //取长度大的数位数
        int[] maxArray = null; //长度大的数
        int[] minArray = null; //长度小的数
        if(numLen1<numLen2){
            minLen = numLen1;
            maxLen = numLen2;
            minArray = numArray1;
            maxArray = numArray2;
        }else{
            minLen = numLen2;
            maxLen = numLen1;
            minArray = numArray2;
            maxArray = numArray1;
        }

        //二维数组存储结果,例如:23*23 ->[[6,9],[4,6]] ,内部括号(低维)存某位的相乘结果,高维低位存个位,十位...
        int[][] resultArray = new int[minLen][maxLen+1];

        //长度大的数*长度小的数的每一位,分别存到相应数组中,然后累加
        for(int h=0;h<minLen;h++){ //高维
            int l=0;
            int added = 0;
            for(;l<maxLen;l++){ //低维
                int t = maxArray[l]*minArray[h]+added; //长度大的数的每一位*长度小的数的个位、十位...
                if(t>9){
                    added = t/10; //进位
                    resultArray[h][l] = t%10; //当前位计算结果
                }else{
                    added = 0; //不进位
                    resultArray[h][l] = t; //当前位计算结果
                }
            }
            resultArray[h][l] = added; //个位、十位...的计算结果的最高位
        }

        //对结果补位(左移),个位不动,十位补0,百位补00...,然后累加
        int[] sum = null; //最终累加结果
        int[] lowBitResult = null; //低位补0结果(前一位)
        for(int h=0;h<minLen;h++){
            int[] bitResult =  resultArray[h];
            int[] r;  //个位、十位...的补0结果
            if(h==0){ //个位
                r  = bitResult;
                sum = r;
                lowBitResult = r; //记录下来,待下次循环累加
            }else{ //十位...的计算结果
                r = new int[resultArray[h].length+h]; //初始化默认就是0的
                int rLen = r.length-1;
                for(int i=bitResult.length-1;i>=0;i--){ //从高位开始复制到新数组
                    r[rLen--] = bitResult[i];
                }
                //累加之前的数
                sum = new int[r.length+1]; //取高位长度+1,可能进位

                //================加法核心算法====================
                //两数长度相同的部分,同位相加,超出9进1
                int added = 0;
                int i=0;
                for(;i<lowBitResult.length;i++){
                    int t = lowBitResult[i]+r[i]+added; //两数相加,再加进位
                    if(t>9){
                        added = 1; //进1
                        sum[i] = t-10; //当前位计算结果
                    }else{
                        added = 0; //不进位
                        sum[i] = t; //当前位计算结果
                    }
                }
                //长度超出部分累加
                for(;i<r.length;i++){
                    int t = r[i]+added; //多余位数加上进位
                    if(t>9){
                        added = 1; //进1
                        sum[i] = t-10; //当前位计算结果
                    }else{
                        added = 0; //不进位
                        sum[i] = t; //当前位计算结果
                    }
                }
                sum[i] = added; //最高位
                //===============================================

                lowBitResult = sum; //记录下来,待下次循环累加
            }
        }

        //拼接结果 [1,4,8,2,0] -> 2841
        StringBuilder builder = new StringBuilder();
        boolean existHighNotZero = false; //高位存在不为0的,这个0就不能移除
        for(int n=sum.length-1;n>=0;n--){
            //移除高位无效的0,保留最后一个0
            if(sum[n]==0 && !existHighNotZero && n!=0){
                continue; //跳过
            }else{
                existHighNotZero = true;
                builder.append(sum[n]);
            }
        }

        return builder.toString();
    }

    /**
     * 两数相除
     * @param numStr1 数1(被除数)
     * @param numStr2 数2(除数,不能超过long型)
     * @return 结果
     */
    public static String divide(String numStr1,String numStr2){
        int numLen1 = numStr1.length();
        int numLen2 = numStr2.length();

        int[] numArray1 = new int[numLen1]; //数字数组
        int[] numArray2 = new int[numLen2];



        // "12345"-> [5,4,3,2,1]
        for(int i=0;i<numLen1;i++){
            String c = numStr1.substring(i,i+1);
            numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }
        for(int i=0;i<numLen2;i++){
            String c = numStr2.substring(i,i+1);
            numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }

        int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认大数长度+16
        int[] resultArray = new int[effectiveNum]; //高位存高位

        //将被除数的每一位除以除数,取整为该位结果,取余暂存借给低位(除数不能大过long型,除非除法转换为减法)
        long yu = 0;
        int resultIndex = effectiveNum-1;
        for(int i=numArray1.length-1;i>=0;i--){
            long num = yu * 10 + numArray1[i]; //被除数该位为:余数*10+自己
            int r= (int)(num / Long.parseLong(numStr2)); //取整
            yu = num % Long.parseLong(numStr2); //取余
            resultArray[resultIndex--] = r;
        }
        int decimalPoint = effectiveNum-numArray1.length-1; //小数点位置
        if(yu!=0){
            int decimal = decimalPoint; //小数
            for(int i=0;i<effectiveNum-numArray1.length;i++){
                long num = yu * 10 + 0; //小数部分被除数补0
                int r= (int)(num / Long.parseLong(numStr2)); //取整
                yu = num % Long.parseLong(numStr2); //取余
                resultArray[decimal--] = r;
                if(yu==0){
                    break; //余数为0,提前退出
                }
            }
        }

        //拼接结果
        StringBuilder builder = new StringBuilder();
        boolean existHighNotZero = false;
        for(int i=effectiveNum-1;i>=0;i--){
            if(i==decimalPoint){
                builder.append(".");
            }
            if(resultArray[i]==0){
                if(!existHighNotZero && i>decimalPoint+1){ //跳过高位无用的0
                    continue;
                }
            }else{
                existHighNotZero = true;
            }
            builder.append(resultArray[i]);
        }
        String result = builder.toString();
        //去除尾部无用的0
        int endIndex = result.length();
        for(int i=result.length()-1;i>=0;i--){
            char c = result.charAt(i);
            if(c!='0'){
                endIndex = i+1;
                break;
            }
        }
        //去除多余的小数点
        if(result.charAt(endIndex-1)=='.'){
            endIndex = endIndex-1;
        }
        result = result.substring(0,endIndex);
        return result;
    }

    /**
     * 两数相除(增强版)
     * @param numStr1 数1(被除数)
     * @param numStr2 数2(除数)
     * @return 结果
     */
    public static String divideEnhanced(String numStr1,String numStr2){
        int numLen1 = numStr1.length();
        int numLen2 = numStr2.length();

        int[] numArray1 = new int[numLen1]; //数字数组
        int[] numArray2 = new int[numLen2];



        // "12345"-> [5,4,3,2,1]
        for(int i=0;i<numLen1;i++){
            String c = numStr1.substring(i,i+1);
            numArray1[numLen1-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }
        for(int i=0;i<numLen2;i++){
            String c = numStr2.substring(i,i+1);
            numArray2[numLen2-i-1] = Integer.parseInt(c); //低位存字符串尾部数字
        }

        int effectiveNum = (numLen1 >= numLen2 ? numLen1:numLen2)+16; //有效位数: 默认大数长度+16
        int[] resultArray = new int[effectiveNum]; //高位存高位

        //将被除数的每一位除以除数,取整为该位结果,取余暂存借给低位(除数不能大过long型,除非除法转换为减法)
        String yu = "0";
        int resultIndex = effectiveNum-1;
        for(int i=numArray1.length-1;i>=0;i--){
            String num = "0".equals(yu)?numArray1[i]+"":add(yu+"0",numArray1[i]+""); //被除数该位为:余数*10+自己
            DivideResult result = getDivideResult(num,numStr2);
            String r= result.getR() ; //取整
            yu = result.getYu(); //取余
            resultArray[resultIndex--] = Integer.parseInt(r); //某位上的结果肯定小于10
        }
        int decimalPoint = effectiveNum-numArray1.length-1; //小数点位置
        if(!"0".equals(yu)){
            int decimal = decimalPoint; //小数
            for(int i=0;i<effectiveNum-numArray1.length;i++){
                String num = yu+"0"; //小数部分被除数补0
                DivideResult result = getDivideResult(num,numStr2);
                String r= result.getR() ; //取整
                yu = result.getYu(); //取余
                resultArray[decimal--] = Integer.parseInt(r);
                if("0".equals(yu)){
                    break; //余数为0,提前退出
                }
            }
        }

        //拼接结果
        StringBuilder builder = new StringBuilder();
        boolean existHighNotZero = false;
        for(int i=effectiveNum-1;i>=0;i--){
            if(i==decimalPoint){
                builder.append(".");
            }
            if(resultArray[i]==0){
                if(!existHighNotZero && i>decimalPoint+1){ //跳过高位无用的0
                    continue;
                }
            }else{
                existHighNotZero = true;
            }
            builder.append(resultArray[i]);
        }
        String result = builder.toString();
        //去除尾部无用的0
        int endIndex = result.length();
        for(int i=result.length()-1;i>=0;i--){
            char c = result.charAt(i);
            if(c!='0'){
                endIndex = i+1;
                break;
            }
        }
        //去除多余的小数点
        if(result.charAt(endIndex-1)=='.'){
            endIndex = endIndex-1;
        }
        result = result.substring(0,endIndex);
        return result;
    }

    /**
     * 校验数字是否合法
     * @param numStr 数字字符串
     * @return 是否合法
     */
    public static boolean numberValid(String numStr){
        Pattern pattern = Pattern.compile("^[1-9]\\d*$|0");
        Matcher matcher = pattern.matcher(numStr);
        return matcher.matches();
    }

    /**
     * 计算大数
     * @param numArray1 数1
     * @param numArray2 数2
     * @return 大数
     */
    public static int[] getMaxNumber(int[] numArray1, int[] numArray2) {
        for(int i=numArray1.length-1;i>=0;i--){
            if(numArray1[i]>numArray2[i]){
                return numArray1;
            }else{
                if(numArray1[i]==numArray2[i]){
                    continue; //待继续比较
                }else{
                    return numArray2;
                }
            }
        }
        return numArray1; //全部相等,返回第一个
    }

    /**
     * 除法转换为减法
     * @param numStr1 数1(被除数)
     * @param numStr2 数2(除数)
     * @return 除的结果
     */
    public static DivideResult getDivideResult(String numStr1,String numStr2){
        DivideResult result = new DivideResult();
        String r = "";
       // String times = "0";
        int times = 0; //取整不会大于9的(被除数(余数+某位)/除数(肯定大于余数)这个过程是,被除数逐渐增大到可以除以除数为止,此时被除数>=除数,刚刚好,所以被除数最多比除数多1位,两数相差肯定小于10倍)
        while (true){
            r=subtract(numStr1,numStr2);
           // times = add(times,"1"); //次数递增
            times++;
            if("0".equals(r)){ //除尽了
                result.setYu("0");
                result.setR(times+"");
                break;
            }else if(r.startsWith("-")){ //负数,多减了一次
                result.setYu(numStr1); //上次减下来多余的数值,就是余数
               // result.setR(subtract(times,"1"));
                result.setR((times-1)+"");
                break;
            }
            numStr1 = r; //被减数重置为剩余的数值
        }
        return result;
    }
}

 

 

package com.hdwang;

/**
 * Created by hdwang on 2017/10/10.
 * 相除结果
 */
public class DivideResult {

    /**
     * 取整结果
     */
    private String r;

    /**
     * 取余结果
     */
    private String yu;

    public String getR() {
        return r;
    }

    public void setR(String r) {
        this.r = r;
    }

    public String getYu() {
        return yu;
    }

    public void setYu(String yu) {
        this.yu = yu;
    }
}
package com.hdwang;

import java.util.Scanner;
import static com.hdwang.Calculator.*;

public class Main {

    public static void main(String[] args) {
        // write your code here


        Scanner scanner = new Scanner(System.in);

        boolean loop = true;

        while (loop) {
            System.out.println("请输入第一个非负整数:");
            String numStr1 = scanner.nextLine();
            if (!numberValid(numStr1)) {
                System.out.println(String.format("%s不合法", numStr1));
                continue;
            }

            System.out.println("请输入第二个非负整数:");
            String numStr2 = scanner.nextLine();
            if (!numberValid(numStr2)) {
                System.out.println(String.format("%s不合法", numStr2));
                continue;
            }

            String r1 = add(numStr1, numStr2);
            System.out.println(String.format("大数加法计算:%s+%s%s=%s", numStr1, numStr2,r1.length()>50?"\n":"", r1));

            try {
                System.out.println("加法直接计算:" + (Long.parseLong(numStr1) + Long.parseLong(numStr2)));
            }catch (Exception ex){
                System.out.println("加法直接计算:"+ex.getClass().getName());
            }

            String r2 = subtract(numStr1, numStr2);
            System.out.println(String.format("大数减法计算:%s-%s%s=%s", numStr1, numStr2,r2.length()>50?"\n":"", r2));
            try {
                System.out.println("减法直接计算:" + (Long.parseLong(numStr1) - Long.parseLong(numStr2)));
            }catch (Exception ex){
                System.out.println("减法直接计算:"+ex.getClass().getName());
            }


            String r3 = multiply(numStr1, numStr2);
            System.out.println(String.format("大数乘法计算:%s*%s%s=%s", numStr1, numStr2,r3.length()>50?"\n":"", r3));
            try {
                System.out.println("乘法直接计算:" + (Long.parseLong(numStr1) * Long.parseLong(numStr2)));
            }catch (Exception ex){
                System.out.println("乘法直接计算:"+ex.getClass().getName());
            }

            try {
                String r4 = divide(numStr1, numStr2);
                System.out.println(String.format("大数除法计算:%s/%s%s=%s", numStr1, numStr2, r4.length() > 50 ? "\n" : "", r4));
            }catch (Exception ex){
                System.out.println("大数除法计算:"+ex.getClass().getName());
            }
            try {
                System.out.println("除法直接计算:" + ((double)Long.parseLong(numStr1) / (double) Long.parseLong(numStr2)));
            }catch (Exception ex){
                System.out.println("除法直接计算:"+ex.getClass().getName());
            }

            String r5 = divideEnhanced(numStr1, numStr2);
            System.out.println(String.format("增强版大数除法计算:%s/%s%s=%s", numStr1, numStr2,r5.length()>50?"\n":"", r5));

            System.out.println("退出输入q,否则继续");
            String line = scanner.nextLine();
            if(line.equalsIgnoreCase("Q")){
                loop = false;
            }else{
                loop  = true;
            }
        }

    }
}

 

运行结果:

请输入第一个非负整数:
1
请输入第二个非负整数:
1
大数加法计算:1+1=2
加法直接计算:2
大数减法计算:1-1=0
减法直接计算:0
大数乘法计算:1*1=1
乘法直接计算:1
大数除法计算:1/1=1
除法直接计算:1.0
增强版大数除法计算:1/1=1
退出输入q,否则继续

请输入第一个非负整数:
2
请输入第二个非负整数:
3
大数加法计算:2+3=5
加法直接计算:5
大数减法计算:2-3=-1
减法直接计算:-1
大数乘法计算:2*3=6
乘法直接计算:6
大数除法计算:2/3=0.6666666666666666
除法直接计算:0.6666666666666666
增强版大数除法计算:2/3=0.6666666666666666
退出输入q,否则继续

请输入第一个非负整数:
25
请输入第二个非负整数:
25
大数加法计算:25+25=50
加法直接计算:50
大数减法计算:25-25=0
减法直接计算:0
大数乘法计算:25*25=625
乘法直接计算:625
大数除法计算:25/25=1
除法直接计算:1.0
增强版大数除法计算:25/25=1
退出输入q,否则继续

请输入第一个非负整数:
100
请输入第二个非负整数:
50
大数加法计算:100+50=150
加法直接计算:150
大数减法计算:100-50=50
减法直接计算:50
大数乘法计算:100*50=5000
乘法直接计算:5000
大数除法计算:100/50=2
除法直接计算:2.0
增强版大数除法计算:100/50=2
退出输入q,否则继续

请输入第一个非负整数:
3
请输入第二个非负整数:
4
大数加法计算:3+4=7
加法直接计算:7
大数减法计算:3-4=-1
减法直接计算:-1
大数乘法计算:3*4=12
乘法直接计算:12
大数除法计算:3/4=0.75
除法直接计算:0.75
增强版大数除法计算:3/4=0.75
退出输入q,否则继续

请输入第一个非负整数:
4
请输入第二个非负整数:
3
大数加法计算:4+3=7
加法直接计算:7
大数减法计算:4-3=1
减法直接计算:1
大数乘法计算:4*3=12
乘法直接计算:12
大数除法计算:4/3=1.3333333333333333
除法直接计算:1.3333333333333333
增强版大数除法计算:4/3=1.3333333333333333
退出输入q,否则继续

请输入第一个非负整数:
1
请输入第二个非负整数:
100
大数加法计算:1+100=101
加法直接计算:101
大数减法计算:1-100=-99
减法直接计算:-99
大数乘法计算:1*100=100
乘法直接计算:100
大数除法计算:1/100=0.01
除法直接计算:0.01
增强版大数除法计算:1/100=0.01
退出输入q,否则继续

请输入第一个非负整数:
100
请输入第二个非负整数:
1
大数加法计算:100+1=101
加法直接计算:101
大数减法计算:100-1=99
减法直接计算:99
大数乘法计算:100*1=100
乘法直接计算:100
大数除法计算:100/1=100
除法直接计算:100.0
增强版大数除法计算:100/1=100
退出输入q,否则继续

请输入第一个非负整数:
1
请输入第二个非负整数:
10000000000
大数加法计算:1+10000000000=10000000001
加法直接计算:10000000001
大数减法计算:1-10000000000=-9999999999
减法直接计算:-9999999999
大数乘法计算:1*10000000000=10000000000
乘法直接计算:10000000000
大数除法计算:1/10000000000=0.0000000001
除法直接计算:1.0E-10
增强版大数除法计算:1/10000000000=0.0000000001
退出输入q,否则继续

请输入第一个非负整数:
1
请输入第二个非负整数:
100000000000000000000000000000000000000000000000000
大数加法计算:1+100000000000000000000000000000000000000000000000000
=100000000000000000000000000000000000000000000000001
加法直接计算:java.lang.NumberFormatException
大数减法计算:1-100000000000000000000000000000000000000000000000000
=-99999999999999999999999999999999999999999999999999
减法直接计算:java.lang.NumberFormatException
大数乘法计算:1*100000000000000000000000000000000000000000000000000
=100000000000000000000000000000000000000000000000000
乘法直接计算:java.lang.NumberFormatException
大数除法计算:java.lang.NumberFormatException
除法直接计算:java.lang.NumberFormatException
增强版大数除法计算:1/100000000000000000000000000000000000000000000000000
=0.00000000000000000000000000000000000000000000000001
退出输入q,否则继续

 

说明:

当数字的大小超过long类型的数值范围时,将无法对数值进行计算,所以必须实现一套算法。曾经上C语言程序设计时做的一套课程设计就是这个题目,当时苦于能力不足,写不起来。如今,用java写出来了加减运算,经过多次测试,准确无误。耗时8.5小时完成,哈哈。至于小数计算,可以转换成整数计算,然后移动小数点位置即可。至于符号带符号的运算也简单,乘除法负负得正,正负得负,正正得正,带负号的加减法可以转换为不待负号的运算。例如:-a-b=-(a+b) ; -a-(-b) = b-a; -a + -b = -(a+b) 等 

文章评论

漫画:程序员的工作
漫画:程序员的工作
10个帮程序员减压放松的网站
10个帮程序员减压放松的网站
要嫁就嫁程序猿—钱多话少死的早
要嫁就嫁程序猿—钱多话少死的早
“肮脏的”IT工作排行榜
“肮脏的”IT工作排行榜
老程序员的下场
老程序员的下场
那些性感的让人尖叫的程序员
那些性感的让人尖叫的程序员
Google伦敦新总部 犹如星级庄园
Google伦敦新总部 犹如星级庄园
一个程序员的时间管理
一个程序员的时间管理
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
那些争议最大的编程观点
那些争议最大的编程观点
程序员的一天:一寸光阴一寸金
程序员的一天:一寸光阴一寸金
60个开发者不容错过的免费资源库
60个开发者不容错过的免费资源库
Web开发人员为什么越来越懒了?
Web开发人员为什么越来越懒了?
“懒”出效率是程序员的美德
“懒”出效率是程序员的美德
团队中“技术大拿”并非越多越好
团队中“技术大拿”并非越多越好
Java程序员必看电影
Java程序员必看电影
编程语言是女人
编程语言是女人
每天工作4小时的程序员
每天工作4小时的程序员
旅行,写作,编程
旅行,写作,编程
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
科技史上最臭名昭著的13大罪犯
科技史上最臭名昭著的13大罪犯
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
看13位CEO、创始人和高管如何提高工作效率
看13位CEO、创始人和高管如何提高工作效率
聊聊HTTPS和SSL/TLS协议
聊聊HTTPS和SSL/TLS协议
程序员应该关注的一些事儿
程序员应该关注的一些事儿
为什么程序员都是夜猫子
为什么程序员都是夜猫子
程序员和编码员之间的区别
程序员和编码员之间的区别
程序员都该阅读的书
程序员都该阅读的书
程序员周末都喜欢做什么?
程序员周末都喜欢做什么?
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
2013年中国软件开发者薪资调查报告
2013年中国软件开发者薪资调查报告
10个调试和排错的小建议
10个调试和排错的小建议
不懂技术不要对懂技术的人说这很容易实现
不懂技术不要对懂技术的人说这很容易实现
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
我的丈夫是个程序员
我的丈夫是个程序员
亲爱的项目经理,我恨你
亲爱的项目经理,我恨你
程序员的鄙视链
程序员的鄙视链
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
程序员最害怕的5件事 你中招了吗?
程序员最害怕的5件事 你中招了吗?
中美印日四国程序员比较
中美印日四国程序员比较
我是如何打败拖延症的
我是如何打败拖延症的
Web开发者需具备的8个好习惯
Web开发者需具备的8个好习惯
 程序员的样子
程序员的样子
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
如何区分一个程序员是“老手“还是“新手“?
如何区分一个程序员是“老手“还是“新手“?
如何成为一名黑客
如何成为一名黑客
2013年美国开发者薪资调查报告
2013年美国开发者薪资调查报告
初级 vs 高级开发者 哪个性价比更高?
初级 vs 高级开发者 哪个性价比更高?
当下全球最炙手可热的八位少年创业者
当下全球最炙手可热的八位少年创业者
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有