JAVA大数处理(BigInteger,BigDecimal)

最新推荐文章于 2024-06-30 21:25:49 发布
最新推荐文章于 2024-06-30 21:25:49 发布
阅读量1k 收藏 2
点赞数
分类专栏： BigDecimal 文章标签： BigDecimal

JAVA大数处理(BigInteger,BigDecimal)  

转自：http://hi.baidu.com/dolphin0520/blog/item/a0c88b1eb8ac86c4a786699e.html

      在用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

Ⅱ.基本常量：

   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());

}

Ⅳ.运用

四则预算：

import java.util.Scanner;
import java.math.*;
import java.text.*;

public class Main 
{
public static void main(String args[])
{
   Scanner cin = new Scanner ( System.in );
   BigInteger a,b;
   int c;
   char op;
   String s;
  
   while( cin.hasNext() )
   {
    a = cin.nextBigInteger();
    s = cin.next();
    op = s.charAt(0);
    if( op == '+')
    {
     b = cin.nextBigInteger();
     System.out.println(a.add(b));
    }
    else if( op == '-')
    {
     b = cin.nextBigInteger();
     System.out.println(a.subtract(b));
    }
    else if( op == '*')
    {
     b = cin.nextBigInteger();
     System.out.println(a.multiply(b));
    }
    else
    {
     BigDecimal a1,b1,eps;
     String s1,s2,temp;
     s1 = a.toString();
       a1 = new BigDecimal(s1);
     b = cin.nextBigInteger();
     s2 = b.toString();
     b1 = new BigDecimal(s2);
     c = cin.nextInt();
     eps = a1.divide(b1,c,4);
     //System.out.println(a + " " + b + " " + c);
     //System.out.println(a1.doubleValue() + " " + b1.doubleValue() + " " + c);
     System.out.print( a.divide(b) + " " + a.mod(b) + " ");
     if( c != 0)
     {
      temp = "0.";
      for(int i = 0; i < c; i ++) temp += "0";
      DecimalFormat gd = new DecimalFormat(temp);
      System.out.println(gd.format(eps));
     }
     else System.out.println(eps);
    }
   }
   }
}


下面是关于大数处理的部分代码。
/**
 * @author zhangyong
 * 
 */
public class BigInt {

/**
 * @param args
 */
public static void main(String[] args) {
BigInt b = new BigInt();
b.add("999", "999");
}

public String add(String a, String b) {
//检查输入
if (!a.matches("\\d+") || !a.matches("\\d+")) {
return null;
}
final int BASE = 10;//10进制
int lenA = a.length();//加数的长度
int lenB = b.length();//被加数的长度
int maxLen, partialSum, carry = 0;//大数的长度，和，进位
maxLen = (lenA > lenB) ? lenA : lenB;
StringBuffer sum = new StringBuffer();
int temA, temB = 0;
for (int i = 0; i < maxLen; i++) {
if (i >= lenA) {
temA = 0;
} else {
temA = Integer.valueOf(a.charAt(lenA - i - 1) - 48);
}
if (i >= lenB) {
temB = 0;
} else {
temB = Integer.valueOf(b.charAt(lenB - i - 1) - 48);
}
partialSum = temA + temB + carry;
carry = partialSum / BASE;
sum.append(partialSum % BASE);
}
if (carry == 1)
sum.append(carry);
System.out.println(a + "+" + b + "=" + sum.reverse().toString());
return sum.reverse().toString();
}
}



另一个版本：
package test;
public class VeryBigNumAdd {

public static void main(String[] args) {
VeryBigNumAdd vbn = new VeryBigNumAdd();
String a = "123453243455535634535252345234677576252241234123523453664563634";
String b = "123453243455535634535252345234677576252241234123523453664563634";
String result = vbn.doAdd(a, b);
System.out.println("result:" + result);
}

String doAdd(String a, String b) {
String str = "";
int lenA = a.length();
int lenB = b.length();
int maxLen = (lenA > lenB) ? lenA : lenB;
int minLen = (lenA < lenB) ? lenA : lenB;
String strTmp = "";
for (int i = maxLen - minLen; i > 0; i--) {
strTmp += "0";
}
// 把长度调整到相同
if (maxLen == lenA) {
b = strTmp + b;
} else
a = strTmp + a;
int JW = 0;// 进位
for (int i = maxLen - 1; i >= 0; i--) {
int tempA = Integer.parseInt(String.valueOf(a.charAt(i)));
int tempB = Integer.parseInt(String.valueOf(b.charAt(i)));
int temp;
if (tempA + tempB + JW >= 10 && i != 0) {
temp = tempA + tempB + JW - 10;
JW = 1;
} else {
temp = tempA + tempB + JW;
JW = 0;
}
str = String.valueOf(temp) + str;
}
return str;
}
}

又一个版本：

import java.util.ArrayList;
import java.util.Collections;
public class VeryLongInt {

ArrayList digits;

// Postcondition: The VeryLongInt is empty.
public VeryLongInt() {
final int INITIAL_CAPACITY = 500;
digits = new ArrayList(INITIAL_CAPACITY);
} // default constructor

// Precondition: n >= 0.
// Postcondition: The VeryLongInt has been initialized from the
// not-very-long int n.
public VeryLongInt(int n) {
final int BASE = 10;
digits = new ArrayList();
do {
digits.add(new Integer(n % BASE));
n = n / BASE;
} // while
while (n > 0);
// digits is now in reverse order, so we reverse:
Collections.reverse(digits);

} // constructor

// Postcondition: The number of elements in the VeryLongInt has
// been returned.
public int size() {
return digits.size();
} // method size

// Precondition: The string s consists of a sequence of characters
// with non-digit characters ignored.
// There are no leading zeroes, except for 0
// itself, which has a single '0'.
// Postcondition: The VeryLongInt has been initialized from s.
public VeryLongInt(String s) {
final char LOWEST_DIGIT_CHAR = '0';
final char HIGHEST_DIGIT_CHAR = '9';
digits = new ArrayList(s.length());
char c;
int digit;
for (int i = 0; i < s.length(); i++) {
c = s.charAt(i);
if ((LOWEST_DIGIT_CHAR <= c) && (c <= HIGHEST_DIGIT_CHAR)) {

digit = c - LOWEST_DIGIT_CHAR;
digits.add(new Integer(digit));
} // if a digit
} // for
} // constructor with string parameter

// Postcondition: The VeryLongInt has been returned as a string of digits.
public String toString() {
final String EMPTY_STRING = "";
String s = EMPTY_STRING;
for (int i = 0; i < digits.size(); i++)
s += digits.get(i);
return s;

} // method toString

// Postcondition: If i >= digits.size(), 0 has been returned; else
// the ith least significant digit in digits has
// been returned. The least significant digit is
// the 0th least significant digit.
private int least(int i) {
if (i >= digits.size())
return 0;
else
return ((Integer) (digits.get(digits.size() - i - 1))).intValue();
} // least

// Postcondition: The VeryLongInt has been incremented by otherVeryLong.
public void add(VeryLongInt otherVeryLong) {
final int BASE = 10;
int largerSize, partialSum, carry = 0;
VeryLongInt sum = new VeryLongInt();
if (digits.size() > otherVeryLong.digits.size())
largerSize = digits.size();
else
largerSize = otherVeryLong.digits.size();

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

partialSum = least(i) + otherVeryLong.least(i) + carry;
carry = partialSum / BASE;
sum.digits.add(new Integer(partialSum % BASE));

} // for

if (carry == 1)
sum.digits.add(new Integer(carry));
Collections.reverse(sum.digits);
digits = sum.digits;
} // method add

// Postcondition: A copy of the calling object has been returned.
public Object clone() {
VeryLongInt temp = new VeryLongInt();
temp.digits = (ArrayList) digits.clone();
return temp;
} // method clone

// Postcondition: true has been returned if the
// value of the VeryLongInt is less than the value
// of otherVeryLong. Otherwise, false
// has been returned.
public boolean less(VeryLongInt otherVeryLong) {

if (digits.size() < otherVeryLong.digits.size())
return true;
if (digits.size() > otherVeryLong.digits.size())
return false;
for (int i = 0; i < digits.size(); i++) {
if (((Integer) (digits.get(i))).intValue() < ((Integer) (otherVeryLong.digits
.get(i))).intValue())
return true;
if (((Integer) (digits.get(i))).intValue() > ((Integer) (otherVeryLong.digits
.get(i))).intValue())
return false;
} // for
return false; // the two objects have the same value
} // method less

// Postcondition: true has been returned if the value of the VeryLongInt
// is greater than the value of otherVeryLong. Otherwise,
// false has been returned.
public boolean greater(VeryLongInt otherVeryLong) {
return otherVeryLong.less(this);
} // method greater

// Postcondition: true has been returned if the value of the VeryLongInt
// is equal to the value of otherVeryLong. Otherwise,
// false has been returned.
public boolean equals(VeryLongInt otherVeryLong) {
return !less(otherVeryLong) && !otherVeryLong.less(this);
} // method equals

// Precondition: n > 0.
// Postcondition: The calling object contains the nth Fibonacci
// number.
public void fibonacci(int n) {
VeryLongInt previous = new VeryLongInt(1), current = new VeryLongInt(1), temp = new VeryLongInt();
digits.clear();
if (n <= 2)
digits.add(new Integer(1));
else {
for (int i = 3; i <= n; i++) {
temp = (VeryLongInt) current.clone();
current.add(previous);
previous = temp;
} // for
digits = current.digits;
} // else

} // method fibonacci

} // class VeryLongInt

Jimmy-尹
关注
专栏目录
java大数运算(BigInteger,BigDecimal)
wangtao的博客
05-13 1688
java中大数运算非常方便 但要记住一些函数 java中的数学函数要加前缀(相较与c++):Math. java多组输入: Scanner in =new Scanner(System.in); while(in.hasNext()) {//多组输入 // } 首先是 头文件:import java.math.BigInteger; BigInteger a =in.nextBigI...
【java】大数（Biglnteger 、BigDecima）
wdy00000的博客
12-20 665
Java中BigInteger方法总结
02-09
BigInteger不是基本数据类型之一，它其实更像String,是Java里的一个类，然而它的初始化方式却没有String那么方便可以直接赋值，而是跟其他自定义的类一样，要调用它的构造器进行初始化。
java——BigDecimal
weixin_42981168的博客
03-06 218
介绍 float和double类型的主要设计目标是为了科学计算和工程计算。他们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，它们没有提供完全精确的结果，所以不应该被用于要求精确结果的场合。但是，商业计算往往要求结果精确，这时候BigDecimal就派上大用场啦。 public class BigDecimalDemo { public static vo...
【Java】BigInteger类
最新发布
qq_39921135的博客
06-30 395
1、如果BigInteger表示的数字没有超出long的范围，可以用静态方法valueOf()获取。2、如果BigInteger表示的数字超出long的范围，就可以使用构造方法获取。3、对象一旦创建，BigInteger内部记录的值是不能发生改变的。4、在代码中，只要你进行了计算（加减乘除），都会产生一个新的BigInteger对象。1、BigInteger表示一个大整数。2、如何获取BigInteger的对象？public BigInteger(String val) // 构造方法。
Java中的BigInteger和 BigDecimal
dongxing515的博客
07-15 381
Integer类作为int的包装类，能存储的最大整型值为2^31-1 ，Long类最大为2^63-1，虽然比Integer类大了很多，但是也是有限的。如果想要表示更大的整数，不管是基本数据类型还是它们对应的包装类都无法实现。Java中提供了两个用于高精度计算的类：BigInteger和BigDecimal，这两个类包含的方法、提供的操作与基本类型及其对应的包装类相同，并提供了java.lang.Math的所有相关方法。BigInteger类实现了任意精度的整数运算，BigDecimal实现了任意精度的浮点数
Java中对大数字的处理之BigInteger与BigDecimal
孤城的博客
12-21 367
在Java开发中不能对一些很大的数字进行编译或者处理，比如使用long型也不够用，会直接编译爆红，这个时候就可以使用BigInteger这个类，下面就用这个类进行数字过大问题的加减乘除运算，演示BigInteger这个类在Java中的作用 输出结果： 对于加减乘除，BigInteger中提供了对应的加减乘除方法，不能像算数运算一样使用+-*/，而是分别为add,subtract,mulitiply,divide，下面演示add方法： 输出结果： ...
java 中的大数据类型（BigInteger和BigDecimal）
克终的博客
08-28 2203
java 中的大数据类型（BigInteger和BigDecimal）
java实现大数加法(BigDecimal)的实例代码
09-04
在Java编程语言中，处理大数（大数据量的整数）加法时，通常会使用`java.math.BigDecimal`类。这个类提供了精确的浮点数运算，特别适合于需要高精度计算的情况，如金融计算或者复杂的数学运算。下面将详细讨论`...
Java中的BigInteger类与BigDecimal类，细解，带例题
12-22
使用时导包：java.math.BigInteger 作用：可以使用BigInteger操作大整数，也可以转换进制。如果在操作的时候一个整型数据已经超过了整数的最大类型长度long的话，则此数据就无法装入，所以，此时要使用BigInteger类...
java笔试题算法-DelphiBigNumbers:Delphi的BigInteger和BigDecimal
06-03
java笔试题算法大数 Delphi 的 BigInteger、BigDecimal 和 BigRational 这些是多精度BigInteger 、 BigDecimal和BigRational类型的实现，从头开始构建。 大整数 BigInteger是一个多精度整数。 它的大小仅受可用内存...
Java高新技术——大数操作（BigInteger、BigDecimal）
热门推荐
李春春的专栏
08-23 8万+
本篇博客主要介绍Java常用类库之大数操作，主要是BigInteger和BigDecimal的API学习。之后介绍华为的一道历年真题，十六进制转换成十进制，我们可以看到题目中给我们设置的陷阱，以及如何解决它！
Java之BigInteger和BigDecimal
lghlhg的博客
12-09 1949
Java的BigInteger是一个用来表示任意长度的整数的类，可以表示整数的值范围从负无穷到正无穷。BigInteger类提供了一系列的方法来支持基本的数学运算，如加、减、乘、除和取模等。它还提供了一些工具方法，如比较两个BigInteger对象的大小、转换为byte数组、字符串表示形式等。BigInteger类的对象是不可变的，即它们一旦被创建就不能被修改。这种特性使得BigInteger类非常适合用来进行精确计算，如金融、稳健算法等领域。
Java BigInteger
赵先森
11-28 551
BigInteger概述 可以让超过Integer范围内的数据进行运算 构造方法 public BigInteger(String val) 成员方法 public BigInteger add(BigInteger val) public BigInteger subtract(BigInteger val) public BigInteger multiply(BigInteger val)...
Java中BigInteger和BigDecimal的用法(写题真的很好用,还精确)
梦心长存的博客
11-10 579
精确 首先,这个经典的问题大家都知道 对于0.2+0.1这个数字,我们都知道是0.3 可是计算机执行的结果却是 0.30000000000000004 原因在于我们的计算机是二进制的。 浮点数没有办法是用二进制进行精确表示。我们的CPU表示浮点数由两个部分组成：指数和尾数，这样的表示方法一般都会失去一定的精确度，有些浮点数运算也会产生一定的误差。 例如：0.4的二进制表示并非就是精确的0.4。...
JAVA之BigInteger
何成俭的博客
09-01 260
用Java来处理高精度问题，相信对很多ACMer来说都是一件很happy的事，简单易懂。用Java刷了一些题，感觉Java还不错，在处理高精度和进制转换中，调用库函数的来处理。下面是写的一些Java中一些基本的函数的及其…… 头文件：import java.io.*; import java.util.*; import java.math.*; 读入： Scanner c
Java中BigInteger类
WenJGo的博客
03-22 1135
Java中BigInteger类
java biginterger_java之BigInteger类
weixin_39524984的博客
02-16 250
1.BigInteger类概述可以让超过Integer范围内的数据进行运算。2.BigInteger类的构造方法public BigInteger(String val) 将BigInteger的十进制字符串表示形式转换为BigIntegerpackagecom;importjava.math.BigInteger;/***BigInteger类*可以让超过Integer范围内的数据进行运...
Java 大数高精度函数（BigInteger）
vloai
12-19 1740
Java 提交格式import .. 头文件 ..public class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); while(cin.hasNext()){ // 等同于 !=EOF T = cin.
Java大数与日期处理：BigInteger, BigDecimal, Date, DateFormat与Calendar详解
在Java编程中，几个重要的类对于数值和日期处理起着关键作用：BigInteger类、BigDecimal类、Date类、DateFormat类以及Calendar类。这些类提供了广泛的功能，使得开发者能够处理超出基本数据类型范围的大数值运算和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值