Java模拟两个大整数的加法、乘法、除法

最新推荐文章于 2024-04-15 20:26:37 发布
最新推荐文章于 2024-04-15 20:26:37 发布
阅读量3.4k 收藏 4
点赞数 2
分类专栏： 算法 文章标签： java 大整数 四则运算 加减乘除
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nmgrd/article/details/62046774
版权 
package ddd;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class BigIntegerAddition {

    /**
     * 
     * 问题：java实现两个大数相加，可能存在溢出。 如123456789 + 987654321 返回 1111111110
     * 
     * 解决办法：
     * 1.直接用BigInteger 
     * 
     * 2.模拟手算加法，进位相加（暂时没有考虑负数的情况），该类模拟两个大数的相加， 相乘，相除。至于相减，看了该类的相加就知道如何实现了。
     * 该类中的加、乘、除的算法思路与人工的计算方式一致。虽然算法目的是达到了，但效率的话的确有待商榷，因为本人能力有限，实在是想不到更好的实现方式，还望
     * 各位路过的高人指点！！！若有更好的实现方式，记得留言咯！
     */
    public static void main(String[] args) {

        String x = "23456789";
        String y = "987654321";

        BigInteger a = new BigInteger(x);
        BigInteger b = new BigInteger(y);
        BigInteger c = a.add(b);
        System.out.println(c.toString());

        System.out.println(add(x, y));

        System.out.println(add("-100", "1"));
        System.out.println(add("-1000", "1"));
        System.out.println(add("-1", "1"));
        System.out.println(add("-17", "901"));

        System.out.println(add("1", "-100"));
        System.out.println(add("1", "-1000"));
        System.out.println(add("1", "-1"));
        System.out.println(add("901", "-17"));

        System.out.println(posMultiPos("556", "7"));

        System.out.println(posMultiPos("195", "5"));

        System.out.println(posMultiPos("919", "8"));

        System.out.println("--->" + trimPrefixedZero("0"));

        System.out.println(posMultiPos("99", "0"));

        System.out.println(divid("138", "12", 6));
        System.out.println(divid("10", "3", 6));

    }


    /**
     * 两个整数的加法运算，考虑正负数，由于减法可以转化为加法运算，
     * 所以本人并没有直接给出求大整数减法的算法
     * @param x
     * @param y
     * @return
     */
    public static String add(String x, String y) {
        if (isNullOrEmpty(x) || isNullOrEmpty(y)) {
            return null;
        }
        if (!isNumeric(x) || !isNumeric(y)) {
            return null;
        }
        if (x.equals("0")) {
            return y;
        }
        if (y.equals("0")) {
            return x;
        }

        if (x.charAt(0) == '-' && y.charAt(0) == '-') {

            x = x.substring(1);
            y = y.substring(1);
            return "-" + posAddPos(x, y);

        } else if (x.charAt(0) != '-' && y.charAt(0) != '-') {

            return posAddPos(x, y);

        } else if (x.charAt(0) == '-' && y.charAt(0) != '-') {

            return negAddPos(x, y);

        } else if (x.charAt(0) != '-' && y.charAt(0) == '-') {

            String tem = x;
            x = y;
            y = tem;
            return negAddPos(x, y);
        }

        return null;
    }


    /**
     * 一个负数与一个正数的加法
     * @param x
     * @param y
     * @return
     */
    public static String negAddPos(String x, String y) {

        if (x.charAt(0) != '-' || y.charAt(0) == '-') {
            throw new IllegalArgumentException("x必须是负数数，y必须是正数");
        }
        // 判断x代表的负数的绝对值是否比正数y的绝对值大
        boolean isAbsXLarger = false;

        x = x.substring(1);

        if (x.length() > y.length()) {
            isAbsXLarger = true;
            String tmp = x;
            x = y;
            y = tmp;
        } else if (x.length() == y.length()) {
            isAbsXLarger = isAbsXLarger(x, y);
            if (isAbsXLarger) {
                String tmp = x;
                x = y;
                y = tmp;
            }
        }

        x = addZeroToFirst(x, y.length());

        int len = y.length();
        int[] a = toIntArray(y);
        int[] b = toIntArray(x);
        int[] c = new int[len + 1];

        for (int i = 0; i < len; i++) {
            int ac = a[len - 1 - i];
            int bc = b[len - 1 - i];

            if (ac - bc >= 0) {
                c[len - i] = ac - bc;
            } else {

                c[len - i] = (ac + 10) - bc;

                int r = 1;
                while ((len - 1 - i - r) >= 0 && a[len - 1 - i - r] == 0) {
                    a[len - 1 - i - r] = 9;
                    r++;
                }
                a[len - 1 - i - r] = a[len - 1 - i - r] - 1;
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i <= len; i++) {
            sb.append(c[i]);
        }

        String z = trimPrefixedZero(sb.toString());

        if (z.equals("0")) {
            z = "";
        }

        if (z.length() > 0 && isAbsXLarger) {
            return "-" + sb.toString();
        } else if (z.length() > 0) {
            return sb.toString();
        } else {
            return "0";
        }
    }


    /**
     * 两个正数的加法
     * @param x
     * @param y
     * @return
     */
    public static String posAddPos(String x, String y) {
        if (x.length() > y.length()) {
            String tmp = x;
            x = y;
            y = tmp;
        }
        x = addZeroToFirst(x, y.length());

        String z = "";
        int len = x.length();
        int[] a = toIntArray(x);
        int[] b = toIntArray(y);
        int[] c = new int[len + 1];
        int d = 0;
        for (int i = 0; i < len; i++) {
            int tmpSum = a[len - 1 - i] + b[len - 1 - i] + d;
            c[len - i] = tmpSum % 10;
            d = tmpSum / 10;
        }
        c[0] = d;

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i <= len; i++) {
            sb.append(c[i]);
        }

        z = trimPrefixedZero(sb.toString());

        return z;
    }

    /**
     * 大整数的乘法
     * @param x
     * @param y
     * @return
     */
    public static String multi(String x, String y) {
        if (isNullOrEmpty(x) || isNullOrEmpty(y)) {
            return null;
        }
        if (!isNumeric(x) || !isNumeric(y)) {
            return null;
        }

        if (x.charAt(0) == '-' && y.charAt(0) == '-') {

            x = x.substring(1);
            y = y.substring(1);
            return posMultiPos(x, y);

        } else if (x.charAt(0) != '-' && y.charAt(0) != '-') {

            return posMultiPos(x, y);

        } else if (x.charAt(0) == '-' && y.charAt(0) != '-') {

            x = x.substring(1);
            return "-" + posMultiPos(x, y);

        } else if (x.charAt(0) != '-' && y.charAt(0) == '-') {

            y = y.substring(1);
            return "-" + posMultiPos(x, y);
        }

        return null;
    }

    /**
     * 一个多位数与一个个位数的乘法，注：这两个数都只能是正数
     * @param x
     * @param y
     * @return
     */
    private static String posMultiSingleDigit(String x, String y) {
        if (y.length() != 1 || x.charAt(0) == '-') {
            throw new IllegalArgumentException("参数异常");
        }
        String z = "";
        int len = x.length();
        int[] a = toIntArray(x);
        int b = Integer.parseInt(y);
        int[] c = new int[len + 1];

        int d = 0;
        for (int i = 0; i < len; i++) {
            int tempV = a[len - 1 - i] * b;
            int r = (tempV % 10) + d;
            d = tempV / 10;
            if (r >= 10) {
                c[len - i] = r - 10;
                d = d + 1;
            } else {
                c[len - i] = r;
            }
        }
        c[0] = d;

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i <= len; i++) {
            sb.append(c[i]);
        }

        z = trimPrefixedZero(sb.toString());

        return z;
    }

    /**
     * 两个正数的乘法
     * @param x
     * @param y
     * @return
     */
    public static String posMultiPos(String x, String y) {
        if (x.length() < y.length()) {
            String tem = x;
            x = y;
            y = tem;
        }

        int[] b = toIntArray(y);
        int len = b.length;

        String[] temp = new String[len];

        for (int i = 0; i < len; i++) {

            temp[len - 1 - i] = posMultiSingleDigit(x, b[len - 1 - i] + "");
            temp[len - 1 - i] += getZeroStringOfLenght(i);
        }

        String result = "0";
        for (int i = 0; i < len; i++) {
            result = posAddPos(result, temp[i]);
        }

        return result;

    }


    /**
     * 大整数的除法, 如果不能整除， 则小数保留位数为precision,如果能整除，则保留一位小数
     * @param x
     * @param y
     * @param precision 小数的精度
     * @return
     */
    public static String divid(String x, String y, int precision) {
        if (isNullOrEmpty(x) || isNullOrEmpty(y)) {
            return null;
        }
        if (!isNumeric(x) || !isNumeric(y)) {
            return null;
        }
        boolean flag = false;

        List<String> li = new ArrayList<String>();
        if (x.charAt(0) == '-' && y.charAt(0) == '-') {

            x = x.substring(1);
            y = y.substring(1);
            posDividPos(x, y, "", li, precision, false);

        } else if (x.charAt(0) != '-' && y.charAt(0) != '-') {

            posDividPos(x, y, "", li, precision, false);

        } else if (x.charAt(0) == '-' && y.charAt(0) != '-') {
            flag = true;
            x = x.substring(1);
            posDividPos(x, y, "", li, precision, false);

        } else if (x.charAt(0) != '-' && y.charAt(0) == '-') {
            flag = true;
            y = y.substring(1);
            posDividPos(x, y, "", li, precision, false);
        }

        String result = "";
        for(String ele : li)
        {
            result += ele;
        }

        result = trimPrefixedZero(result);

        if(flag && !result.equals("0")) {
            result = "-" + result;
        }

        return result;
    }


    /**
     * 两个正整数的除法
     * @param x
     * @param y
     * @param temp
     * @param li
     */
    private static void posDividPos(String x, String y, String temp, List<String> li, int precision, boolean dotIncluded) {

        if (x.length() == 0 && precision  == 0) {
            return;
        }

        char[] charArray = x.toCharArray();
        String[] xArray = new String[charArray.length];
        for (int i = 0; i < charArray.length; i++) {
            String s = String.valueOf(charArray[i]);
            xArray[i] = s;
        }

        List<String> xList = new ArrayList<String>(Arrays.asList(xArray));
        if (xList.size() > 0) {
            temp += xList.remove(0);
        } else {
            if(!dotIncluded) {
                li.add(".");
                dotIncluded = true;
            }

            if(precision > 0) {
                precision--;
                temp += "0";  
            }
        }
        temp = trimPrefixedZero(temp);

        while (isAbsXLarger(y, temp)) {
            li.add("0");
            if (xList.size() > 0) {
                temp = temp + xList.remove(0);
            } else if(precision > 0) {
                if(!dotIncluded) {
                    li.add(".");
                    dotIncluded = true;
                }
                temp = temp + "0";
                precision--;
                temp = trimPrefixedZero(temp);
                if(temp.equals("0")) {
//                  return;
                }
            } else {
                return;
            }
        }

        int k = cacu(temp, y);
        li.add(k + "");
        String result = add(temp, "-" + posMultiSingleDigit(y, k + ""));
        result = trimPrefixedZero(result);

        if (result.equals("0")) {
            result = "";
        }
        temp = result;

        String newX = "";
        for (String str : xList) {
            newX += str;
        }
        System.out.println(result);
        posDividPos(newX, y, result, li, precision, dotIncluded);
    }

    public static String getZeroStringOfLenght(int a) {
        String str = "";
        for (int i = 0; i < a; i++) {
            str += "0";
        }
        return str;
    }

    public static int[] toIntArray(String str) {
        int len = str.length();
        int[] result = new int[len];
        for (int i = 0; i < len; i++) {
            result[i] = str.charAt(i) - '0';
        }
        return result;
    }

    public static String addZeroToFirst(String str, int length) {
        StringBuilder sb = new StringBuilder();
        int diff = length - str.length();
        while (diff > 0) {
            sb.append("0");
            diff--;
        }
        sb.append(str);
        return sb.toString();
    }

    public static boolean isNumeric(String str) {
        Pattern p = Pattern.compile("^\\-?[0-9]*$");
        Matcher isNum = p.matcher(str);
        return isNum.matches();
    }

    public static boolean isNullOrEmpty(String str) {
        if (str == null) {
            return true;
        }
        if (("").equals(str.trim())) {
            return true;
        }
        return false;
    }

    public static boolean isAbsXLarger(String x, String y) {
        if (x.length() > y.length()) {
            return true;
        } else if (x.length() == y.length()) {

            int[] xArray = toIntArray(x);
            int[] yArray = toIntArray(y);
            for (int i = 0; i < xArray.length; i++) {
                if (xArray[i] > yArray[i]) {
                    return true;
                } else if (xArray[i] == yArray[i]) {
                    continue;
                } else {
                    return false;
                }
            }
        }

        return false;
    }

    public static String trimPrefixedZero(String z) {
        while (z.length() > 1 && z.charAt(0) == '0') {
            z = z.substring(1);
        }
        return z;
    }

    /**
     * 该方法相当于求 x/y的值，注意x、y都是一个正整数
     * @param x
     * @param y
     * @return
     */
    public static int cacu(String x, String y) {

        int k = 0;
        for (int i = 0; i <= 9; i++) {
            if (isAbsXLarger(x, posMultiSingleDigit(y, i + "")) || (x.equals(posMultiSingleDigit(y, i + "")))) {
//              System.out.println(x);
//              System.out.println(posMultiSingleDigit(y, i + ""));
                k = i;
            }
        }

        return k;

    }

}
lhever_
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java程序计算两个大整数相乘
仙路看近行远
08-02 6794
方法1 ：用两个字符串保存输入的大整数，然后用第二个字符串的每一位去乘第一个字符串的数字值，最后将每次的结果错位相加即可。时间复杂度高O（n^2） 方法2：将两个大整数X,Y每次分割成两半，第一个分割成AB，第二个分割成CD。所以最后结果XY=（A*10^n/2 +B）（C*10^m/2+D）;进行分解可得 XY=AC*10^(n+m)/2+AD*10^n/2 +BC*10^m/2 +BD;
Java教程：任意大整数的相加运算
CZ-001的博客
09-19 2239
大家好，今天我给大家带来了一个小程序，它实现了对两个任意大整数的相加运算。我们知道，在Java中对整数进行运算可以使用int类型，如果范围不够，可以使用long，再大可以使用double，如果想对更大的整数运算可以使用BigInteger类。今天，我们就自己来编写一段程序，实现对两个任意大的整数的加法运算。
【Java】算法积累1——大整数相加
weixin_62984531的博客
11-06 851
算法刚刚入门，每次记录下自己所学的知识总结以及理解，希望能够帮助大家，如有内容有错误或可改进的地方，欢迎一起探讨，一起进步，在此也要感谢WYSCODER学长给我的学习建议
Java实现超大整数加法
最新发布
z_wonderland_的博客
04-15 210
【代码】Java实现超大整数加法。
Java大数字运算
m0_69505153的博客
05-19 707
Java大数字运算
java大数相除怎么做_浅谈一下大数相除有关思路(图解)与用java代码具体解决方案...
weixin_39548733的博客
02-23 538
浅谈一下大数相除有关思路(图解)与用java代码具体解决方案PS:接上篇大数相乘博客。两数的正负情况在这就不谈了，只要加一个标记就可以了。此文阅读前提:需在解决了大数相加减和大数相乘的基础上进行。在完成了大数相乘的程序后，很自然地想到了在不使用javaAPI的情况下，如何实现两个数相除，两数可以是大数和小数的任意组合，如大数/大数，大数/小数。思路图解1:刚开始想到的思路如下,以82/4为例St...
高精度加法减法乘法除法
08-24
本主题将详细探讨高精度加法、减法、乘法和除法的实现方法及其背后的原理。 首先，我们要理解常规的计算机数据类型如int和float的局限性。int类型在大多数系统中通常只能存储32位或64位的整数，对于较大的数值，会...
java中最大的整数用法分析
08-30
这些方法可以实现不同类型的整数运算，例如加法、减法、乘法、除法和取余数等。 例如，下面是一个使用 BigInteger 类进行加法运算的示例代码： ```java package org.aaa; import java.math.BigInteger; public ...
Vivado下无符号及有符号 16_32bit 整数 乘法 除法 加法 减法 及开方的IP实现及仿真验证
01-16
基于Vivado 2020.2下 16bit 32bit 无符号及有符号整数 乘法 除法 加法 减法 及开方的 IP核实现与仿真验证
(PHP实现)只使用++运算实现加法,减法,乘法,除法
10-27
最后，除法`chufa($d, $e)`是最复杂的部分，需要用到两个循环。外层while循环用于寻找能整除$d的最小正整数$k，内层循环则是通过调用`chengfa()`来计算每次自增$k后的结果$f。当$f大于或等于$d时，跳出循环并返回$k...
JAVA实验报告 处理大整数
01-24
`BigInteger`类提供了丰富的功能，包括加法、减法、乘法、除法以及更多高级操作。在实验中，首先通过构造方法`BigInteger(String val)`创建了两个大整数`n1`和`n2`，这个构造方法会将给定的字符串转换成大整数对象。...
Java程序练习-长整数加法运算
jinghuainfo
10-03 367
长整数加法运算时间限制: 2000ms内存限制: 2000kB描述问题描述：设计一个实现任意长的整数进行加法运算的演示程序。 基本要求：利用双向循环链表实现长整数的存储，每个结点含一个整形变量。任何整形变量的范围是 -(2^15 - 1)~(2^15 - 1)。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。输入-9999,9999（输入第一个加数） 1,0000,00...
算法---两个超大整数相乘
qq_38345598的博客
04-05 4756
处理问题时有时候会遇到两个超大数相乘,那么他们的乘积整数就有可能存不下。 说一下各个整型的范围 类型说明 名称 字节数 范围 int 4 -2147483648~2147483647 short int 2 -3276...
java 减法 位运算_通过位运算实现两个数的加、减、乘、除-JAVA成长之路
weixin_39976960的博客
02-13 304
//通过位运算实现两个数的加、减、乘、除publicclassBitSuan{//(1)加法运算publicstaticintadd(inta,intb){intsum=a;while(b!=){//a与b无进位相加sum=a^b;b=(a&b)a=sum;}returnsum;}//负数按位置取反+1publicstaticintnegNum(intn){returnadd(~n,1);...
大整数加法java_大整数的加法java
weixin_26717737的博客
02-21 896
姓名: 胡双兴 一:实验题目:大整数加法 学号:090610213 班级:090413 1 问题分析:处理多位整数的加法,这些整数无法在计算机硬件允许的范围内表示和处理。 2:数学......java自定义大数,并实现了两个大数的加减乘除以及比较,以及2~62进制任意数(包括但不限于正整数与负整数)的相互转化 java 自定义大数(进制可在 2~62 之间相互......c++大整数加减法,报告_...
BigDecimal除法后保留两位小数
热门推荐
haibin_hu的专栏
07-31 11万+
BigDecimal numBigDecimal=new BigDecimal(5.33); numBigDecimal=ConvertNumber(numBigDecimal,3,2);//调用,5.33/3后保留两位小数1.7766666=1.78 //BigDecimal 截取小数位，四舍五入 public BigDecimal ConvertNumber(BigDecimal bi
Java——大数加法
weixin_44084024的博客
05-23 1098
一、题目描述 以字符串的形式读入两个数字，编写一个函数计算它们的和，以字符串形式返回。 数据范围：s.length,t.length≤100000，字符串仅由’0’~‘9’构成 要求：时间复杂度 O(n)O(n) 注：long的最大值:9223372036854775807 即long的最大值才19位，而t的最大长度是10万位 二、我的答案 import java.util.*; import java.math.BigInteger; public class Solution { /**
【面试题】Java 2个(多个)大整数相加如何实现
石臻臻的杂货铺(szzdzhp001)
06-28 4389
之前面试阿里的时候，第四面的时候面试官让我当他面实现这个题目， 一开始的时候问的时候 2个相加如何实现，然后我写完了之后又问我如果是多个相加呢？面试官希望我能在实现的时候能够考虑到各种可能性，比如多个数相加，然后等我写完了之后，又问我有没有更好的实现方法；以下是我的实现方法； 将待相加的数以字符串的形式进行相加 简单思路就是 多个字符串的每一位进行相加，如果有进位 ，则让进位也一起相加； ...
【Java】输入两个数字，计算其加减乘除
choulongpiao9663的博客
04-04 4871
import java.util.Scanner; public class Test01 { public static void main(String[] args) { System.out.println("输入"); Scann...
go语言编写程序实现加法减法乘法除法取整函数
03-31
以下是go语言编写程序实现加法减法乘法除法取整函数的示例代码： ```go package main import ( "fmt" ) func add(x, y int) int { return x + y } func subtract(x, y int) int { return x - y } func multiply(x, y int) int { return x * y } func divide(x, y int) int { return x / y } func main() { x := 10 y := 3 fmt.Println("Addition:", add(x, y)) fmt.Println("Subtraction:", subtract(x, y)) fmt.Println("Multiplication:", multiply(x, y)) fmt.Println("Division:", divide(x, y)) } ``` 运行结果： ``` Addition: 13 Subtraction: 7 Multiplication: 30 Division: 3 ``` 其中，add()函数实现了两个整数相加的功能；subtract()函数实现了两个整数相减的功能；multiply()函数实现了两个整数相乘的功能；divide()函数实现了两个整数相除并取整的功能。在main()函数中，我们分别调用这些函数，并输出它们的返回值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值