GVKun编程网logo

BigInteger：以可扩展方法计算小数位数

31

如果您想了解BigInteger：以可扩展方法计算小数位数的相关知识，那么本文是一篇不可错过的文章，我们将为您提供关于17_java之Integer|System|Arrays|Math|BigInt

如果您想了解BigInteger：以可扩展方法计算小数位数的相关知识，那么本文是一篇不可错过的文章，我们将为您提供关于17_java之Integer|System|Arrays|Math|BigInteger|BigDecimal、34-BigInteger详解、BigDecimal和BigInteger的限制是什么？、BigInteger & BigDecimal的有价值的信息。

本文目录一览：

BigInteger：以可扩展方法计算小数位数

BigInteger：以可扩展方法计算小数位数

我需要计算的小数位数BigInteger。例如：

  • 99 退货 2
  • 1234 退货 4
  • 9999 退货 4
  • 12345678901234567890 退货 20

我需要做的这 一个BigInteger与184948十进制数字多。 我该如何快速且可扩展？

在 转换到字符串的 方法是缓慢的：

public String getWritableNumber(BigInteger number) {   // Takes over 30 seconds for 184948 decimal digits   return "10^" + (number.toString().length() - 1);}

这种 按十个循环进行循环的 方法甚至更慢：

public String getWritableNumber(BigInteger number) {    int digitSize = 0;    while (!number.equals(BigInteger.ZERO)) {        number = number.divide(BigInteger.TEN);        digitSize++;    }    return "10^" + (digitSize - 1);}

有没有更快的方法？

答案1

小编典典

这看起来像在工作。我还没有进行详尽的测试，也没有进行任何时间的测试，但似乎运行时间合理。

public class Test {  /**   * Optimised for huge numbers.   *   * http://en.wikipedia.org/wiki/Logarithm#Change_of_base   *   * States that log[b](x) = log[k](x)/log[k](b)   *   * We can get log[2](x) as the bitCount of the number so what we need is   * essentially bitCount/log[2](10). Sadly that will lead to inaccuracies so   * here I will attempt an iterative process that should achieve accuracy.   *   * log[2](10) = 3.32192809488736234787 so if I divide by 10^(bitCount/4) we   * should not go too far. In fact repeating that process while adding (bitCount/4)   * to the running count of the digits will end up with an accurate figure   * given some twiddling at the end.   *    * So here''s the scheme:   *    * While there are more than 4 bits in the number   *   Divide by 10^(bits/4)   *   Increase digit count by (bits/4)   *    * Fiddle around to accommodate the remaining digit - if there is one.   *    * Essentially - each time around the loop we remove a number of decimal    * digits (by dividing by 10^n) keeping a count of how many we''ve removed.   *    * The number of digits we remove is estimated from the number of bits in the    * number (i.e. log[2](x) / 4). The perfect figure for the reduction would be   * log[2](x) / 3.3219... so dividing by 4 is a good under-estimate. We    * don''t go too far but it does mean we have to repeat it just a few times.   */  private int log10(BigInteger huge) {    int digits = 0;    int bits = huge.bitLength();    // Serious reductions.    while (bits > 4) {      // 4 > log[2](10) so we should not reduce it too far.      int reduce = bits / 4;      // Divide by 10^reduce      huge = huge.divide(BigInteger.TEN.pow(reduce));      // Removed that many decimal digits.      digits += reduce;      // Recalculate bitLength      bits = huge.bitLength();    }    // Now 4 bits or less - add 1 if necessary.    if ( huge.intValue() > 9 ) {      digits += 1;    }    return digits;  }  // Random tests.  Random rnd = new Random();  // Limit the bit length.  int maxBits = BigInteger.TEN.pow(200000).bitLength();  public void test() {    // 100 tests.    for (int i = 1; i <= 100; i++) {      BigInteger huge = new BigInteger((int)(Math.random() * maxBits), rnd);      // Note start time.      long start = System.currentTimeMillis();      // Do my method.      int myLength = log10(huge);      // Record my result.      System.out.println("Digits: " + myLength+ " Took: " + (System.currentTimeMillis() - start));      // Check the result.      int trueLength = huge.toString().length() - 1;      if (trueLength != myLength) {        System.out.println("WRONG!! " + (myLength - trueLength));      }    }  }  public static void main(String args[]) {    new Test().test();  }}

在我的Celeron M笔记本电脑上花了大约3秒钟，因此它在某些不错的工具包上应该不到2秒钟。

17_java之Integer|System|Arrays|Math|BigInteger|BigDecimal

17_java之Integer|System|Arrays|Math|BigInteger|BigDecimal

 01基本数据类型对象包装类概述

*A:基本数据类型对象包装类概述
   *a.基本类型包装类的产生
       在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，
　　　　根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等
   *b.八种基本类型对应的包装类
       char    Character
       int     Integer
       byte    Byte
       short   Short
       long    Long
       float   Float
       double  Double
       boolean Boolean

02Integer类parseInt方法

*A:Integer类parseInt方法:
    *a:parseInt()
        int i = Integer.parseInt("12");
        System.out.println(i/2);//6
     
    *b:parseInt(String s, int radix)
        /*
         * Integer类静态方法parseInt(String s, int radix)
         * radix基数,进制
         * "110",2 含义 前面的数字是二进制的,但是方法parseInt运行结果都是十进制
         *  指定进制的字符串转换为十进制的整数
         */
        public static void function_1(){
            int i = Integer.parseInt("110", 2);
            System.out.println(i);
        }

03Integer类int转成字符串

*A:Integer类int转成字符串:
   *a:使用+与字符串拼接
        int i = 3;
        String s = i+"";
        System.out.println(s+1);//"31"
  
   *b:toString(int ,int 进制),任意进制整数转成任意进制的字符串 (了解)
        String s1 = Integer.toString(5,2);
        System.out.println(s1);

04Integer类构造方法

*A:Integer类构造方法
    /*
     *  Integer类构造方法
     *   Integer (String s)
     *   将数字格式的字符串,传递到Integer类的构造方法中
     *   创建Integer对象,包装的是一个字符串
     *   将构造方法中的字符串,转成基本数据类型,调用方法,非静态的, intValue()
     */
    public static void function_3(){
        Integer in = new Integer("100");
        int i = in.intValue();
        System.out.println(--i);//99
    }

05Integer类其他方法

*A:Integer类其他方法 
/* 
 * Integer类的3个静态方法 
 * 做进制的转换 
 * 十进制转成二进制 toBinarString(int) 
 * 十进制转成八进制 toOctalString(int)
 *十进制转成十六进制 toHexString(int) 
* 三个方法,返回值都是以String形式出现 
*/ 
a:十进制转二,八,十六进制 

public static void function_1(){ 
　  System.out.println(Integer.toBinaryString(99));
　  System.out.println(Integer.toOctalString(99)); 
　　System.out.println(Integer.toHexString(999)); 
} 
b:获取int的最大值和最小值 
/* 
 * Integer类的静态成员变量 
 * MAX_VALUE * MIN_VALUE 
 */ 
 public static void function(){ 
　　System.out.println(Integer.MAX_VALUE);
    System.out.println(Integer.MIN_VALUE);
 }

06自动装箱和自动拆箱

*A:自动装箱与自动拆箱: 

//JDK1.5新特性 
//自动装箱,拆箱的 好处: 基本类型和引用类直接运算 
//自动装箱:使用Integer.valueOf(整数值)返回一个封装了该整数值的Integer对象 
//自动拆箱:使用Integer对象.intValue()返回Integer对象中封装的整数值 public static void function(){ 
//引用类型 , 引用变量一定指向对象 //自动装箱, 基本数据类型1, 直接变成了对象

    Integer in = 1; // Integer in = new Integer(1)
    //in 是引用类型,不能和基本类型运算, 自动拆箱,引用类型in,转换基本类型 
    //in+1  ==> in.inValue()+1 = 2    
    //in = 2    自动装箱
    in = in + 1; 
    System.out.println(in);
    
}

07自动装箱和自动拆箱(当心陷阱!!!)

*A:自动装箱与自动拆箱: 
　　Integer i = new Integer(1); 
　　Integer j = new Integer(1); 
　　System.out.println(i==j); // false 比较的是地址
　　System.out.println(i.equals(j)); // true 继承的是Object重写equals,比较的对象的数据值

    System.out.println("===================");
    
    Integer a = 500;//Integer integer=Integer.valueOf(500)
                    //integer=new Integer(500);
    Integer b = 500;
    System.out.println(a==b);//false
    System.out.println(a.equals(b));//true
    
    System.out.println("===================");
 
    //数据在byte(-128~127)范围内,JVM不会从新new对象
    Integer aa = 127; // Integer aa = new Integer(127)
    Integer bb = 127; // Integer bb = aa;
    System.out.println(aa==bb); //true
    System.out.println(aa.equals(bb));//true

08System类方法currentTimeMillis

A:System类方法currentTimeMillis():用于计算程序的执行时间 /* * 获取系统当前毫秒值 * static long currentTimeMillis() * 对程序执行时间测试 */

 public static void function(){ long start = System.currentTimeMillis();
//当前时间x-1970年1月1日零时零分零秒 for(int i = 0 ; i < 10000; i++){ System.out.println(i); } long end = System.currentTimeMillis();

//当前时间y-1970年1月1日零时零分零秒 System.out.println(end - start);//当前时间y-当前时间x }

09System类方法exit

*A:System类方法exit()方法
         /*
         *  退出虚拟机,所有程序全停止
         *  static void exit(0)
         */
        public static void function_1(){
            while(true){
                System.out.println("hello");
                System.exit(0);//该方法会在以后的finally代码块中使用(讲到再说)
            }
        }

10System类方法gc

A:System类方法gc public class Person { public void finalize(){ System.out.println("垃圾收取了"); } }


    /*
     *  JVM在内存中,收取对象的垃圾
     *  当没有更多引用指向该对象时,会自动调用垃圾回收机制回收堆中的对象
     *  同时调用回收对象所属类的finalize方法()
     *  static void gc()
     */
    public static void function_2(){
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        System.gc();
    }

11System类方法getProperties

A:System类方法getProperties(了解) 

/* 
 * 获取当前操作系统的属性:例如操作系统名称, 
 * static Properties getProperties() 
 */ 

public static void function_3(){ 
　　System.out.println( System.getProperties() ); 
}

12System类方法arraycopy

 A:System类方法arraycopy：
  /*
   * System类方法,复制数组
   * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
   * Object src, 要复制的源数组
   * int srcPos, 数组源的起始索引
   * Object dest,复制后的目标数组
   * int destPos,目标数组起始索引 
   * int length, 复制几个
   */
  public static void function_4(){
    int[] src = {11,22,33,44,55,66};
    int[] desc = {77,88,99,0};
    
    System.arraycopy(src, 1, desc, 1, 2);//将src数组的1位置开始(包含1位置)的两个元素,拷贝到desc的1,2位置上
    for(int i = 0 ;  i < desc.length ; i++){
        System.out.println(desc[i]);
    }
  }

13Math类的方法_1

A:Math类中的方法 /*

static double sqrt(double d)

返回参数的平方根*/public static void function_4(){ double d = Math.sqrt(-2); System.out.println(d);}

/*0

static double pow(double a, double b)

a的b次方*/public static void function_3(){double d = Math.pow(2, 3);System.out.println(d);}

/*

static double floor(double d)

返回小于或者等于参数d的最大整数*/public static void function_2(){double d = Math.floor(1.5);System.out.println(d);}

/*

static double ceil(double d)

返回大于或者等于参数d的最小整数*/public static void function_1(){double d = Math.ceil(5.1);System.out.println(d);}

/*

static int abs(int i)

获取参数的绝对值*/ public static void function(){int i = Math.abs(0);System.out.println(i); }

14Math类的方法_2

A:Math类的方法_2 /*

static double round(doubl d)

获取参数的四舍五入,取整数*/ public static void function_6(){ double d = Math.round(5.4195); System.out.println(d); }

/*
static double random() 返回随机数 0.0-1.0之间
来源,也是Random类*/ 

public static void function_5(){ 
　　for(int i = 0 ; i < 10 ;i++){ 
　　double d = Math.random(); System.out.println(d); 
} }

15Arrays工具类

A:Arrays工具类: public class ArraysDemo { public static void main(String[] args) { 
function_2(); int[] arr = {56,65,11,98,57,43,16,18,100,200}; 

int[] newArray = test(arr); System.out.println(Arrays.toString(newArray));
 } 

/*
* 定义方法,接收输入,存储的是10个人考试成绩 * 将最后三个人的成绩,存储到新的数组中,返回新的数组 
*/ public static int[] test(int[] arr){ 

//对数组排序 Arrays.sort(arr); 

//将最后三个成绩存储到新的数组中 int[] result = new int[3]; 

//成绩数组的最后三个元素,复制到新数组中 

// System.arraycopy(arr, 0, result, 0, 3); for(int i = 0 ; i < 3 ;i++){ result[i] = arr[i]; } return result; }

    /*
     *  static String toString(数组)
     *  将数组变成字符串
     */
    public static void function_2(){
        int[] arr = {5,1,4,6,8,9,0};
        String s = Arrays.toString(arr);
        System.out.println(s);
    }
    
    /*
     *  static int binarySearch(数组, 被查找的元素)
     *  数组的二分搜索法
     *  返回元素在数组中出现的索引
     *  元素不存在, 返回的是  (-插入点-1)
     */
    public static void function_1(){
        int[] arr = {1,4,7,9,11,15,18};
        int index =  Arrays.binarySearch(arr, 10);
        System.out.println(index);
    }   
    /*
     *  static void sort(数组)
     *  对数组升序排列
     */
    public static void function(){
        int[] arr = {5,1,4,6,8,9,0};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
} 

16数组复制练习

*A:数组复制练习: 
public static void main(String[] args) { 

int[] arr = {56,65,11,98,57,43,16,18,100,200}; 

int[] newArray = test(arr); 
System.out.println(Arrays.toString(newArray)); 
} 

/* 
* 定义方法,接收输入,存储的是10个人考试成绩 
* 将最后三个人的成绩,存储到新的数组中,返回新的数组 
*/ 
public static int[] test(int[] arr){ 
//对数组排序 Arrays.sort(arr); 
//将最后三个成绩存储到新的数组中 int[] result = new int[3]; 
//成绩数组的最后三个元素,复制到新数组中
//System.arraycopy(arr, 0, result, 0, 3); for(int i = 0 ; i < 3 ;i++){ result[i] = arr[i]; } return result; }

17BigInteger类概述和构造方法

A:BigInteger类概述和构造方法 
public static void main(String[] args) { function(); } 
/*
 *BigInteger类的构造方法
 *传递字符串,要求数字格式,没有长度限制
 **/

public static void function(){ 
　　BigInteger b = new BigInteger("8465846668464684562385634168451684568645684564564"); 
　　System.out.println(b); 
　　BigInteger b1 = new BigInteger("5861694569514568465846668464684562385634168451684568645684564564"); 
　　System.out.println(b1);
}

18BigInteger类四则运算

A:BigInteger类四则运算 public static void main(String[] args) { function_1(); } 

/* 
* BigInteger对象的四则运算 
* 调用方法计算,计算结果也只能是BigInteger对象 
*/ 
public static void function_1(){ 
　 　 BigInteger b1 = new BigInteger("5665464516451051581613661405146"); 
　　  BigInteger b2 = new BigInteger("965855861461465516451051581613661405146");
     //计算 b1+b2对象的和,调用方法 add
     BigInteger bigAdd = b1.add(b2);//965855867126930032902103163227322810292
     System.out.println(bigAdd);
     
     //计算b1-b2对象的差,调用方法subtract
     BigInteger bigSub = b1.subtract(b2);
     System.out.println(bigSub);
     
     //计算b1*b2对象的乘积,调用方法multiply
     BigInteger bigMul = b1.multiply(b2);
     System.out.println(bigMul);
     
     //计算b2/b1对象商,调用方法divied
     BigInteger bigDiv = b2.divide(b1);
     System.out.println(bigDiv);
 }

19员工案例的子类的编写

A:BigDecimal类概述

/*
 * 计算结果,未知
 * 原因: 计算机二进制中,表示浮点数不精确造成
 * 超级大型的浮点数据,提供高精度的浮点运算, BigDecimal
System.out.println(0.09 + 0.01);//0.09999999999999999
System.out.println(1.0 - 0.32);//0.6799999999999999
System.out.println(1.015 * 100);//101.49999999999999
System.out.println(1.301 / 100);//0.013009999999999999 
*/

20BigDecimal类实现加法减法乘法

A:BigDecimal类实现加法减法乘法 /*

BigDecimal实现三则运算

**/

public static void function(){
　　BigDecimal b1 = new BigDecimal("0.09");
　　BigDecimal b2 = new BigDecimal("0.01");
　　//计算b1+b2的和,调用方法addBigDecimal bigAdd = b1.add(b2);System.out.println(bigAdd);

　　BigDecimal b3 = new BigDecimal("1");
　　BigDecimal b4 = new BigDecimal("0.32");

　　//计算b3-b2的差,调用方法subtractBigDecimal 
　　bigSub = b3.subtract(b4);
　　System.out.println(bigSub);

　　BigDecimal b5 = new BigDecimal("1.015");
　　BigDecimal b6 = new BigDecimal("100");

　　//计算b5*b6的成绩,调用方法 
　　multiplyBigDecimal bigMul = b5.multiply(b6);
　　System.out.println(bigMul);}

21BigDecimal类实现除法

 A:BigDecimal类实现除法
 /*
  * BigDecimal实现除法运算
  * divide(BigDecimal divisor, int scale, int roundingMode) 
  * int scale : 保留几位小数
  * int roundingMode : 保留模式
  * 保留模式 阅读API文档
  *   static int ROUND_UP  向上+1
  *   static int ROUND_DOWN 直接舍去
  *   static int ROUND_HALF_UP  >= 0.5 向上+1
  *   static int ROUND_HALF_DOWN   > 0.5 向上+1 ,否则直接舍去
  */
 public static void function_1(){
    BigDecimal b1 = new BigDecimal("1.0301");
    BigDecimal b2 = new BigDecimal("100");
    //计算b1/b2的商,调用方法divied
    BigDecimal bigDiv = b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);//0.01301
    System.out.println(bigDiv);
 }

 

34-BigInteger详解

34-BigInteger详解

在用C或者C++处理大数时感觉非常麻烦，但是在Java中有两个类BigInteger和BigDecimal分别表示大整数类和大浮点数类，至于两个类的对象能表示最大范围不清楚，理论上能够表示无线大的数，只要计算机内存足够大。

这两个类都在java.math.*包中，因此每次必须在开头处引用该包。


Ⅰ基本函数：

1.valueOf(parament); 将参数转换为制定的类型

比如 int a=3;

BigInteger b=BigInteger.valueOf(a);

则b=3;

String s=”12345”;

BigInteger c=BigInteger.valueOf(s);

则c=12345；


2.add(); 大整数相加

BigInteger a=new BigInteger(“23”);

BigInteger b=new BigInteger(“34”);

a. add(b);


3.subtract(); 相减

4.multiply(); 相乘

5.divide(); 相除取整

6.remainder(); 取余

7.pow(); a.pow(b)=a^b

8.gcd(); 最大公约数

9.abs(); 绝对值

10.negate(); 取反数

11.mod(); a.mod(b)=a%b=a.remainder(b);

12.max(); min();

13.punlic int comareTo();

14.boolean equals(); 是否相等

15.BigInteger构造函数：

一般用到以下两种：

BigInteger(String val);

将指定字符串转换为十进制表示形式；

BigInteger(String val,int radix);

将指定基数的 BigInteger 的字符串表示形式转换为 BigInteger

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main {
	public static Scanner cin = new Scanner(System.in);
	public static void main(String[] args) {
		
		BigInteger bi1 = new BigInteger("100");
		BigInteger bi2 = new BigInteger("3");
		
		//四则运算及取余，函数返回值为运算值，但不改变原对象(bi1)
		System.out.println("+: " + bi1.add(bi2)); 
		System.out.println("-: " + bi1.subtract(bi2));
		System.out.println("*: " + bi1.multiply(bi2));
		System.out.println("/: " + bi1.divide(bi2));
		System.out.println("%: " + bi1.remainder(bi2)); 
		System.out.println("%: " + bi1.mod(bi2)); 
		
		
		//同时返回商和余数：
		BigInteger[] arr = bi1.divideAndRemainder(bi2); 
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	
}

　　

Ⅱ.基本常量：

A=BigInteger.ONE 1

B=BigInteger.TEN 10

C=BigInteger.ZERO 0

Ⅲ.基本操作

1. 读入：

用Scanner类定义对象进行控制台读入,Scanner类在java.util.*包中

Scanner cin=new Scanner(System.in);// 读入

while(cin.hasNext()) //等同于!=EOF

{

int n;

BigInteger m;

n=cin.nextInt(); //读入一个int;

m=cin.BigInteger();//读入一个BigInteger;

System.out.print(m.toString());

}
 

if( a.compareTo(b) == 0 ) System.out.println("a == b"); //大整数a==b

else if( a.compareTo(b) > 0 ) System.out.println("a > b"); //大整数a>b

else if( a.compareTo(b) < 0 ) System.out.println("a < b"); //大整数a<b


//大整数绝对值

System.out.println(a.abs()); //大整数a的绝对值


//大整数的幂

int exponent=10;

System.out.println(a.pow(exponent)); //大整数a的exponent次幂

 

//返回大整数十进制的字符串表示

System.out.println(a.toString());

 

//返回大整数p进制的字符串表示

int p=8;

System.out.println(a.toString(p));

　　

BigDecimal和BigInteger的限制是什么？

BigDecimal和BigInteger的限制是什么？

这个问题已经在这里有了答案 ：

BigInteger是否有上限？[重复] （3个答案）

没有限制的BigInteger是什么意思？ （4个答案）

7年前关闭。

我在程序中将两个非常大的BigIntegervalues相乘。失败了 BigInteger和的限制是BigDecimal什么？

BigInteger & BigDecimal

BigInteger & BigDecimal

　　

成员方法   加减乘除
* public BigInteger add(BigInteger val)
* public BigInteger subtract(BigInteger val)
* public BigInteger multiply(BigInteger val)
* public BigInteger divide(BigInteger val)

 


* public BigInteger[] divideAndRemainder(BigInteger val)      同时返回除数和余数

 

 

A:BigDecimal的概述
　　* 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
　　* 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

* 不可变的、任意精度的有符号十进制数。* B:构造方法　　* public BigDecimal(String val)* C:成员方法　　* public BigDecimal add(BigDecimal augend)　　* public BigDecimal subtract(BigDecimal subtrahend)　　* public BigDecimal multiply(BigDecimal multiplicand)　　* public BigDecimal divide(BigDecimal divisor)

我们今天的关于BigInteger：以可扩展方法计算小数位数的分享就到这里，谢谢您的阅读，如果想了解更多关于17_java之Integer|System|Arrays|Math|BigInteger|BigDecimal、34-BigInteger详解、BigDecimal和BigInteger的限制是什么？、BigInteger & BigDecimal的相关信息，可以在本站进行搜索。

本文标签：

上一篇java.lang.System.currentTimeMillis（）替换方法（java替换replace）

下一篇为什么int j = 012给出输出10？（int("20",16)为什么结果为32）

相关文章