学以致用——Java源码——自定义40位长整数类及测试类（通过字符串解析构造、静态方法求和等）（Huge Integer Class）

最新推荐文章于 2023-05-20 21:17:05 发布
最新推荐文章于 2023-05-20 21:17:05 发布
阅读量1.7k 收藏 14
点赞数 4
分类专栏： Java编程（Java Programming）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hpdlzu80100/article/details/85627856
版权

2020/02/19补记：

使用Java BigInteger类测试通过。（仅限两个大整数都为40位的情况，且第一个数字大于第二个数字。现在发现，自定义的这个类的设计更像是面向过程设计而不是面向对象设计。）

测试结果如下：

b1: 3456789012345678901234567890123456789012, b2:2345678901234567890123456789012345678901

加法操作：5802467913580246791358024679135802467913

减法操作：1111110111111111011111111101111111110111

乘法操作：8108517052278739222374662673952145142565060698363359281084621249233290657035812

除法操作：0

最大数：3456789012345678901234567890123456789012

最小数：2345678901234567890123456789012345678901

商是：1；余数是：1111110111111111011111111101111111110111

等价性是：false

比较操作: b1>b2

参考文章：

Java核心技术——Java BigInteger类（大整数类） 

-------------------------------------------------------------------------------------------------------------------

以下为正文：

功能：

1. 使用字符串解析构建一个40位的整数

2. 实现加减运算及其他一些方法（比较大小等）

参考文章：

自定义40位大整数类及测试类（Define a huge integer and implement its arithmetic operation），

https://blog.csdn.net/hpdlzu80100/article/details/2318646

测试结果：

长整数3：3456789012345678901234567890123456789012

长整数4：2345678901234567890123456789012345678901

长整数3和长整数4不相等（使用isEqualTo方法）

长整数3和长整数4不相等（使用isNotEqualTo方法）

长整数3大于长整数4（使用isGreaterThan方法）

长整数3大于长整数4（使用isLessThan方法）

长整数3大于等于长整数4（使用isGreaterThanOrEqualTo方法）

长整数3大于长整数4（使用isLessThanOrEqualTo方法）

长整数3和长整数4的和为：

Huge Integer: 5802467913580246791358024679135802467913

长整数3和长整数4的差为：

Huge Integer: 1111110111111111011111111101111111110111

 

长整数3：2345678901234567890123456789012345678901

长整数4：2345678901234567890123456789012345678901

长整数3和长整数4相等（使用isEqualTo方法）

长整数3和长整数4相等（使用isNotEqualTo方法）

长整数3小于等于长整数4（使用isGreaterThan方法）

长整数3大于等于长整数4（使用isLessThan方法）

长整数3大于等于长整数4（使用isGreaterThanOrEqualTo方法）

长整数3小于等于长整数4（使用isLessThanOrEqualTo方法）

长整数3和长整数4的和为：

 

长整数3：2345678901234567890123456789012345678901

长整数3和长整数4的和为：4691357802469135780246913578024691357802

长整数3和长整数4的差为：

Huge Integer: 0000000000000000000000000000000000000000

长整数3等于零

 

代码：

1. 实体类HugeInteger

//JHTP Exercise 8.16: Huge Integer Class
//by pandenghuang@163.com
/**
 * 8.16 (Huge Integer Class) Create a class HugeInteger which uses a 40-element
 * array of digits to store integers as large as 40 digits each. Provide methods
 * parse, toString, add and subtract. Method parse should receive a String,
 * extract each digit using method charAt and place the integer equivalent of
 * each digit into the integer array. For comparing HugeInteger objects, provide
 * the following methods: isEqualTo, isNotEqualTo, isGreaterThan, isLessThan,
 * isGreaterThanOrEqualTo and isLessThanOrEqualTo. Each of these is a predicate
 * method that returns true if the relationship holds between the two
 * HugeInteger objects and returns false if the relationship does not hold.
 * Provide a predicate method isZero. If you feel ambitious, also provide
 * methods multiply, divide and remainder. [Note: Primitive boolean values can
 * be output as the word “true” or the word “false” with format specifier %b.]
 * 
 * @author pandenghuang@163.com
 *
 */
public class HugeInteger {
	final static int SIZE = 40;	//自定义长整数的位数
    private int[ ] singleDigits=new int[SIZE];
    private int[ ] carry=new int[SIZE];
    
    /**
     * 无参构造函数(所有位初始化为0)
     */
    public HugeInteger()
    {
        for (int i=0;i<singleDigits.length;i++)
            singleDigits[i]=0;
    }
    /**
     * 使用HugeInteger构造一个HugeInteger（复制）
     * @param hugeI
     */
    public HugeInteger(int[] hugeI)
    {
        for (int i=0;i<singleDigits.length;i++)
            singleDigits[i]=hugeI[i];
    }
    
    /**
     * 解析一个字符串为HugeInteger
     * @param hugeI
     */
    public static HugeInteger parse(String hugeIntegerText)
    {
    	int[ ] singleDigits=new int[SIZE];
        for (int i=0;i<SIZE;i++)
            singleDigits[i]=Integer.parseInt(String.valueOf(hugeIntegerText.charAt(i)));
        
        return new HugeInteger(singleDigits);
    }
    
    
    /**
     * 重置（所有位初始化为0）
     * @param hugeI
     */
    public void reset()
    {
        for (int i=0;i<singleDigits.length;i++)
            singleDigits[i]=0;
    }
    
    
    /**
     * 返回大整数的格式化输出字符串
     */
    public String toString()
    {    
    	String s="";
        for (int i=0;i<singleDigits.length;i++)
        	s += singleDigits[i];
        
        return String.format("%s",s);
    }
    
    public void output()
    {    System.out.print("Huge Integer: ");
        for (int i=0;i<singleDigits.length;i++)
            System.out.print(singleDigits[i]);
            System.out.println();
    }
    
    public void add(HugeInteger HI)
    {  int[] repository=new int[41];
        for (int i=singleDigits.length-1;i>=0;i--) 
            {
            if (i<singleDigits.length-1)
            carry[i]=(singleDigits[i]+HI.singleDigits[i]+carry[i+1])/10;
            else
                carry[i]=(singleDigits[i]+HI.singleDigits[i])/10;
            if (i<singleDigits.length-1)
            repository[i+1]=(singleDigits[i]+HI.singleDigits[i]+carry[i+1])%10;
            else 
                repository[i+1]=(singleDigits[i]+HI.singleDigits[i])%10;
            }
        repository[0]=(carry[1]+singleDigits[0]+HI.singleDigits[0])/10;
           if (repository[0]==1)
               {
               System.out.print("Overflow Error!!! ");
               reset();
               }
           else
               for (int i=0;i<singleDigits.length;i++ )
                  singleDigits[i]=repository[i+1];
           
    }
    
    /**
     * 静态方法（类方法），2019年1月2日重写
     * @param hi1 hugeInteger1
     * @param hi2 hugeInteger2
     * @return
     */
    public static HugeInteger add(HugeInteger hi1, HugeInteger hi2)
    {  int[] repository=new int[SIZE+1];
       int[] carry = new int[SIZE];  //进位
       int[] result = new int[SIZE];
        for (int i=SIZE-1;i>=0;i--)   //从低位（右侧）开始计算
            {
            if (i<SIZE-1) //最低位以外的位上的进位要考虑上一位上的进位
            carry[i]=(hi1.singleDigits[i]+hi2.singleDigits[i]+carry[i+1])/10;
            else //最低位上的进位（i=SIZE-1）
                carry[i]=(hi1.singleDigits[i]+hi2.singleDigits[i])/10;
            
            if (i<SIZE-1) //最低位以外的位上的求和的结果（要考虑上一位上的进位）
            repository[i+1]=(hi1.singleDigits[i]+hi2.singleDigits[i]+carry[i+1])%10;
            else //最低位求和的结果（i=SIZE-1）
                repository[i+1]=(hi1.singleDigits[i]+hi2.singleDigits[i])%10;
            }
        repository[0]=(carry[1]+hi1.singleDigits[0]+hi2.singleDigits[0])/10;
           if (repository[0]==1)
               {
               System.out.print("Overflow Error!!! ");
               return new HugeInteger();
               }
           else {
               for (int i=0;i<SIZE;i++) 
                  result[i]=repository[i+1];  //将计算结果由高位（对应数组低位）赋值给结果数组
                  return new HugeInteger(result);}
    }
    
    public boolean substract(HugeInteger HI)
    {
        boolean underflowFlag=false;
        int[] repository=new int[41];
        for (int i=singleDigits.length-1;i>=1;i--)
        {
        if (singleDigits[i]-HI.singleDigits[i]>=0)
            repository[i+1]=singleDigits[i]-HI.singleDigits[i];
        else
        {
            repository[i+1]=10+singleDigits[i]-HI.singleDigits[i];
            singleDigits[i-1]-=1;
        }
        }
        
        repository[0]=singleDigits[0]-HI.singleDigits[0];
         if (repository[0]<0)
           {
           System.out.print("Overflow Error!!! ");
           reset();
           return(underflowFlag=true);
           }
       else
       {   repository[1]=singleDigits[0]-HI.singleDigits[0];
           for (int i=0;i<singleDigits.length;i++ )
               singleDigits[i]=repository[i+1];
           return(underflowFlag);
         }
    }
    
    public boolean isEqualTo(HugeInteger HI){
        boolean equalFlag=true;
        for (int i=0;i<singleDigits.length;i++)
            if (singleDigits[i]!=HI.singleDigits[i])
            {equalFlag=false;
            break;
            }
        return equalFlag;
    }
    
    public boolean isNotEqualTo(HugeInteger HI){
        
        
        return !isEqualTo(HI);
    }
    
    public boolean isGreaterThan(HugeInteger hi){
        boolean greaterThanFlag=false;
        for (int i=0;i<singleDigits.length;i++)
            {
            if (singleDigits[i]>hi.singleDigits[i])
                {greaterThanFlag=true;
                break;}
            else if (singleDigits[i]<hi.singleDigits[i])
                    {greaterThanFlag=false;
                    break;}
            }
    return greaterThanFlag;
    }
    
    public boolean isLessThan(HugeInteger HI){
        boolean lessThanFlag=false;
        for (int i=0;i<singleDigits.length;i++)
        { if (singleDigits[i]<HI.singleDigits[i])
            {lessThanFlag=true;
            break;}
            else if (singleDigits[i]>HI.singleDigits[i])
            {lessThanFlag=false;
            break;}
            }
        return lessThanFlag;
    }
    
    public boolean isGreaterThanOrEqualTo(HugeInteger HI){
        
        return !isLessThan(HI);
    }
    
    public boolean isLessThanOrEqualTo(HugeInteger HI){
    
        return !isGreaterThan(HI);
        
    }
    
    public boolean isZero(){
        boolean zeroFlag=false;
        int tempSum=0;
        for (int i=0;i<singleDigits.length;i++)
            tempSum+=singleDigits[i];
            if (tempSum==0)
                zeroFlag=true;
        return zeroFlag;
    }
}

2. 测试类

//JHTP Exercise 8.15: Rational Numbers
//by pandenghuang@163.com
/**
* 8.16 (Huge Integer Class) Create a class HugeInteger which uses a 40-element
* array of digits to store integers as large as 40 digits each. Provide methods
* parse, toString, add and subtract. Method parse should receive a String,
* extract each digit using method charAt and place the integer equivalent of
* each digit into the integer array. For comparing HugeInteger objects, provide
* the following methods: isEqualTo, isNotEqualTo, isGreaterThan, isLessThan,
* isGreaterThanOrEqualTo and isLessThanOrEqualTo. Each of these is a predicate
* method that returns true if the relationship holds between the two
* HugeInteger objects and returns false if the relationship does not hold.
* Provide a predicate method isZero. If you feel ambitious, also provide
* methods multiply, divide and remainder. [Note: Primitive boolean values can
* be output as the word “true” or the word “false” with format specifier %b.]
* 
* @author pandenghuang@163.com
*
*/

public class HugeIntegerTest{
	
    public static void main(String[] args)
    {
    	
//
//        int[] initializer1=new int[40];
//        for (int i=0;i<40;i++)
//            initializer1[i]=(int)(10*Math.random());
//           
//        int[] initializer2=new int[40];
//        for (int j=0;j<40;j++)
//            initializer2[j]=(int)(10*Math.random());
//        
//        
//        
//        HugeInteger HI1=new HugeInteger(initializer1);
//        HugeInteger HI2=new HugeInteger(initializer2);
//        
//        
//        HI1.output();
//        HI2.output();
//        System.out.println();
//        
//
//        
//        
//        System.out.println("These two huge integers are equal: "+HI1.isEqualTo(HI2));
//        System.out.println("These two huge integers are not equal: "+HI1.isNotEqualTo(HI2));
//        System.out.println("1st huge integer is larger than 2nd: "+HI1.isGreaterThan(HI2));
//        System.out.println("1st huge integer is less than 2nd: "+HI1.isLessThan(HI2));
//        System.out.println("1st huge integer is larger than or equal to 2nd: "+
//                HI1.isGreaterThanOrEqualTo(HI2));
//        System.out.println("1st huge integer is less than or equal to 2nd: "+
//                HI1.isLessThanOrEqualTo(HI2));
//        HI1.add(HI2);
//        System.out.print("The sum is: ");
//        HI1.output();
//        HI1.substract(HI2);
//        HI1.substract(HI2);
//        System.out.print("The difference is: ");
//        HI1.output();
//        HI1.add(HI2);
        
    	HugeInteger hi3 = HugeInteger.parse("3456789012345678901234567890123456789012");
    	HugeInteger hi4 = HugeInteger.parse("2345678901234567890123456789012345678901");
        System.out.printf("长整数3：%s%n",hi3);
        System.out.printf("长整数4：%s%n",hi4);
        System.out.printf("长整数3和长整数4%s相等（使用isEqualTo方法）%n",hi3.isEqualTo(hi4)?"":"不");
        System.out.printf("长整数3和长整数4%s相等（使用isNotEqualTo方法）%n",hi3.isNotEqualTo(hi4)?"不":"");
        System.out.printf("长整数3%s长整数4（使用isGreaterThan方法）%n",hi3.isGreaterThan(hi4)?"大于":"小于");
        System.out.printf("长整数3%s长整数4（使用isLessThan方法） %n",hi3.isLessThan(hi4)?"小于":"大于");
        System.out.printf("长整数3%s长整数4（使用isGreaterThanOrEqualTo方法）%n",
                hi3.isGreaterThanOrEqualTo(hi4)?"大于等于":"小于");
        System.out.printf("长整数3%s长整数4（使用isLessThanOrEqualTo方法）%n",
                hi3.isLessThanOrEqualTo(hi4)?"小于等于":"大于");
        System.out.printf("长整数3和长整数4的和为：%n");
        hi3.add(hi4);
        hi3.output();
        hi3 = HugeInteger.parse("3456789012345678901234567890123456789012");
        System.out.printf("长整数3和长整数4的差为：%n");
        hi3.substract(hi4);
        hi3.output();
        
    	hi3 = HugeInteger.parse("2345678901234567890123456789012345678901");
    	hi4 = HugeInteger.parse("2345678901234567890123456789012345678901");
        System.out.printf("%n长整数3：%s%n",hi3);
        System.out.printf("长整数4：%s%n",hi4);
        System.out.printf("长整数3和长整数4%s相等（使用isEqualTo方法）%n",hi3.isEqualTo(hi4)?"":"不");
        System.out.printf("长整数3和长整数4%s相等（使用isNotEqualTo方法）%n",hi3.isNotEqualTo(hi4)?"不":"");
        System.out.printf("长整数3%s长整数4（使用isGreaterThan方法）%n",hi3.isGreaterThan(hi4)?"大于":"小于等于");
        System.out.printf("长整数3%s长整数4（使用isLessThan方法） %n",hi3.isLessThan(hi4)?"小于":"大于等于");
        System.out.printf("长整数3%s长整数4（使用isGreaterThanOrEqualTo方法）%n",
                hi3.isGreaterThanOrEqualTo(hi4)?"大于等于":"小于");
        System.out.printf("长整数3%s长整数4（使用isLessThanOrEqualTo方法）%n",
                hi3.isLessThanOrEqualTo(hi4)?"小于等于":"大于");
        System.out.printf("长整数3和长整数4的和为：%n",HugeInteger.add(hi3, hi4));
//        hi3.add(hi4);
//        hi3.output();
//        hi3 = HugeInteger.parse("2345678901234567890123456789012345678901");
        System.out.printf("%n长整数3：%s%n",hi3);
        System.out.printf("长整数3和长整数4的和为：%s%n",HugeInteger.add(hi3, hi4));
        hi3 = HugeInteger.parse("2345678901234567890123456789012345678901");
        System.out.printf("长整数3和长整数4的差为：%n");
        hi3.substract(hi4);
        hi3.output();
        System.out.printf("长整数3%s零%n",hi3.isZero()?"等于":"不等于");

    }
    
}

 

预见未来to50
关注
  • 4
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
HugeInteger:创建一个服务HugeInteger，该服务使用40个元素的数字数组存储每个最大40位数字的整数。 提供解析，toString，加法和减法的方法。 方法解析应该接收一个字符串，使用charAt方法提取每个数字，并将每个数字的整数等值放入整数数组。 为了比较HugeInteger对象，请提供以下方法
05-16
巨大整数 创建一个服务HugeInteger，该服务使用40个元素的数字数组存储每个最大40位数字的整数。 提供解析，toString，加法和减法的方法。 方法解析应该接收一个字符串，使用charAt方法提取每个数字，并将每个数字的整数等值放入整数数组。 为了比较HugeInteger对象，请提供以下方法：isEqualTo，isNotEqualTo，isGreaterThan，isLessThan，isGreaterThanOrEqualTo和isLessThanOrEqualTo。 每个方法都是一个谓词方法，如果两个HugeInteger对象之间的关系成立，则返回true；如果关系不成立，则返回false。 提供谓词方法为“零”。
HugeInteger
05-09
创建一个大整数类HugeInteger，该类用一个40个元素的数组来存放一个大整数（最多不超过40位）。 构造函数原型： HugeInteger(String); （1）定义几个大整数算术运算的成员函数，包括input、output、add和sub, add, sub的函数原型为 HugeInteger operation(HugeInteger) input的函数原型为 void input(String) 功能是改变大数的值为String的值。 output的函数原型为void output() 功能是将大数输出,即打印到屏幕上。 （2）定义几个大整数关系运算的成员函数，包括isEqualTo、isNotEqualTo、isGreaterThan、isLessThan、isGreaterThanOrEqualTo和isLessThanOrEqualTo。每个函数的返回值为布尔类型。 函数原型为 boolean operation(HugeInteger) 注意: 1. 大数运算需要考虑到正负，使用单独的变量存储符号位。 2. 大数的输入: 正数形式为”12345”，负数形式为”-123456” 3. 如果运算溢出，截取低40位结果。 4. 包名hugeinteger 中i为小写，类名HugeInteger中I为大写。
c++ 大整数库 big integer
10-15
c++ 大整数库 big integer 来自https://mattmccutchen.net/bigint/
C++ 创建HugeInteger(大整数)类
weixin_74287172的博客
05-20 1355
提供成员函数input(输)、output(输出)、add(加)和substract(减)。为了比较 HugeInteger 对象，提供函数isEqualTo(是等于)isNotEqualTo(是不等于)、isGreaterThan(是大于)、isLessThan(是小于)、isGreaterThanOrEqualTo(是大于等于)和isLessThanOrEqualTo(是小于等于)，这几个函数每个都是“判定”函数，如果两个HugeInteger对象间关系成立，则返回true;
自定义40位大整数类及测试类（Define a huge integer and implement its arithmetic operation）
预见未来to50的专栏
04-23 4293
 //Define a huge integer and implement its arithmetic calculation//Java how to program, 5/e, Exercise 8.10import javax.swing.*;public class HugeInteger {    private int[ ] singleDigits=new int[40]
基于JAVA的推箱子游戏设计软件程序源码+word毕业论文文档.zip
04-24
基于JAVA的推箱子游戏设计软件程序源码+word毕业论文文档. 基于JAVA的推箱子游戏系统主要用于实现游戏推箱子功能，提供多种不同难度的关卡。本系统结构如下： （1）初始化模块: 该模块包括屏幕初始化和游戏第一关的...
Huge Integer
07-18
实现1~40为的整数（超过int、long等类型的范围）的加减乘除
HugeInteger大整数计数器作业
08-08
HugeInteger Class) Create a class HugeInteger that uses a 40-element array of digits to store integers as large as 40 digits each. Provide member functions input, output, add and subtract. For comparing HugeInteger objects, provide functions isEqualTo, isNotEqualTo, isGreaterThan, isLessThan, isGreaterThanOrEqualTo and isLessThanOrEqualTo — each of these is a “predicate” function that simply returns true if the relationship holds between the two HugeIntegers and returns false if the relationship does not hold. Also, provide a predicate function isZero.  If you feel ambitious, provide member functions multiply, divide and modulus
java字符转转长整型_P104 将数字字符串转换成长整型整数 ★★
weixin_35538148的博客
02-27 1176
所属年份：2011.3;2011.9;请编函数fun，其功能是将一个数字字符串转换成与其面值相同的长整型整数。可调用strlen函数求字符串的长度。例如：在键盘输入字符串2345210，函数返回长整型数2345210。#include #include long fun( char *s ){}main(){ char s[10]; long r;printf("请输入一个...
Java 算法 特殊的数字四十
joreng的博客
01-19 420
目录标题题目描述解题思路代码 题目描述 特殊的数字四十 输入 输入描述: 　　1234是一个非常特殊的四位数，因为它的各位数之和为10，编程求所有这样的四位十进制数。 输入样例: 输出 输出描述: 　　按从小到大的顺序输出满足条件的四位十进制数。每个数字占用一行。 输出样例: HINT:时间限制：1.0s 内存限制：256.0MB 解题思路 就分别判断每个位上的数字相加是否等于10就行 代码 public class Main { public static void main(String[
java实现创建一个大整数类HugeInteger实现大整数的各类运算
永远在奔跑的学习者
11-15 1931
创建一个大整数类HugeInteger实现大整数的各类运算 程序文件名：HugeInteger.java package pack2; import java.math.BigInteger; import java.util.Scanner; public class HugeInteger { public static void main(String[] args) { Syste...
两个40位的大数组相乘，hugeinteger
mayaohao的博客
05-21 688
package shuzuxiangcheng;import java.util.Scanner;public class Hugeinteger { int a[]=new int[40]; int b[]=new int[40]; int cc[]=new int[40]; int c[]=new int[40]; int d[]=new int[40]; int e[]=new int[40...
定义HugeInt类能处理20亿以上的整数（c++）
qq_40821469的博客
09-20 1707
算法思想：将大数存入数组，再对数组进行逐位操作。 #include <cstring> #include <string> #include <iostream> using namespace std; //算法思想：将大数存入数组，再对数组进行逐位操作 class HugeInt { public: HugeInt(long val = 0); // long型数转换构造为HugeInt型 HugeInt(const char
高精度
Sophon
03-23 225
HugeInt.h #ifndef HUGEINT_H #define HUGEINT_H #include <iostream> #include <string> using std::ostream; using std::string; class HugeInt { friend ostream &operator<<(ostream &a...
光纤振动传感器的研究.doc
最新发布
07-16
传感器

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值