⑴ java 很长的大数 如何用String 相加，相乘
相加比较简单，用单层循环就能实现。进位的话因为加法只存在进1和不进两种情况，用一个boolean型标记一下就能实现。
相乘的有难度。
⑵ 求JAVA代码，要求输入两个数，实现超大数的相加和相减
package test;
public class DoubleTest {
/**
* @param args
*/
public static void main(String[] args) {
System.out.println(Long.MAX_VALUE);//最大数:9223372036854775807
System.out.println(Long.MIN_VALUE);//最小数:-9223372036854775808
System.out.println(Double.MAX_VALUE);//最大数:1.7976931348623157E308
System.out.println(Double.MIN_VALUE);//最小数:4.9E-324
Double a = 9223372036854775807d;
Double b = 9223372036854775807d;
Double c =a+b;
System.out.println(c);
}
}
用Double型吧。最大了。
⑶ JAVA超大整数的加法如何改成减法
你这个道题很有意思，应该是怎么使用算法吧：
减法从各位开始计算，需要判断减数仿中野和被减数的大小：
A.当减数>=被减数，标记后一位不用退位
B.当减数<被减数，标记后一位需要退位
代码如下：
publicclassHandleLargeNumber{
publicstaticvoidmain(String[]args){
inta[]={0,9,9,7,9,4,5,6,7,2,3,4,5,6,4,7,8,9,8,7,6,9};
intb[]={0,0,5,9,1,6,4,5,6,2,3,4,5,7,2,1,3,4,0,3,备喊2,9};
jianFa(a,b);
//下面是验证：通过BigInteger来做
BigIntegera1=newBigInteger("997945672345647898769");
BigIntegera2=newBigInteger("59164562345721340329");
System.out.println(a1.subtract(a2));
}
publicstaticvoidjianFa(int[]a,int[]b){
intidx1=getStart(a);
print(a,idx1);
intidx2=getStart(b);
print(b,idx2);
booleanisTui=false;//是否退位标记
intc[]=newint[a.length];
for培芦(inti=a.length;i>idx1;i--){
if(!isTui){
//不退位
intaNum=a[i-1];
intbNum=b[i-1];
if(aNum>=bNum){
c[i-1]=aNum-bNum;
isTui=false;
}else{
c[i-1]=10+aNum-bNum;
isTui=true;
}
}else{
//退位
intaNum=a[i-1]-1;
intbNum=b[i-1];
if(aNum>=bNum){
c[i-1]=aNum-bNum;
isTui=false;
}else{
c[i-1]=10+aNum-bNum;
isTui=true;
}
}
}
System.out.printf(" 等于: ");
print(c,getStart(c));
}
privatestaticintgetStart(int[]arr){
for(inti=0;i<arr.length;i++){
if(arr[i]!=0){
returni;
}
}
return0;
}
privatestaticvoidprint(int[]arr,intstart){
for(inti=start;i<arr.length;i++){
System.out.printf("%d",arr[i]);
}
System.out.print(" ");
}
}
上面的例子只适用用减数大于被减数，当减数小于被减数时，需要额外的计算，不过思路差不多，复杂度大了很多，呵呵。
亲，如果回答满意，请及时采纳，谢谢！！！
⑷ java数组实现大数相加
package com.nileader.big.entity;
public class BigInt {
private String data_str; //原始数据
private int digit; //数据位数
private int[] data; //大数
private boolean carry = false; //进位标识符
/**
* setter and getter
*/
public boolean isCarry() {
return carry;
}
public void setCarry(boolean carry) {
this.carry = carry;
}
public String getData_str() {
return data_str;
}
public void setData_str(String data_str) {
this.data_str = data_str;
}
public int[] getData() {
return data;
}
public void setData(int[] data) {
this.data = data;
}
public int getDigit() {
return digit;
}
public void setDigit(int digit) {
this.digit = digit;
}
//构造方法
public BigInt(){};
public BigInt(String str_data)
{
this.setData_str(str_data);
}
//基本操作
/**
* 形成大数 初始化
*/
public void initBInt()
{
this.setDigit( this.getData_str().length() );
this.data = new int[this.getDigit()];
//将字符组成的大数逆序放入int[] data中
for(int i = 0, j=this.getDigit() ; i
{
// 1104 --> data[0] = '4',data[1] = '0',data[2]=1, data[3]= '1'
this.data[i] = Integer.parseInt( this.getData_str().substring(j-1,j) );
}
}
/**
* 进行大数相加操作
*/
public void add( BigInt bint)
{
//this的位数大于bint的位数
if( this.getDigit() < bint.getDigit() )
{
int[] datatemp = this.getData();
this.setData( bint.getData());
bint.setData( datatemp);
this.setDigit(this.getData().length);
bint.setDigit(bint.getData().length);
}
//将短的那个先加完
int i =0;
for(; i
{
int tdata = 0;
//上次运算有进位
if( this.isCarry())
{
tdata = this.getData()[i] + bint.getData()[i] +1;
//取消进位标识
this.setCarry(false);
}
else tdata = this.getData()[i] + bint.getData()[i] ;
//本次结果无进位
if(tdata <10) this.data[i] = tdata;
//本次结果有进位
else if(tdata >=10)
{
this.data[i] = tdata -10;
this.setCarry(true);
}
} //短的那个加完了
//剩余数的处理
for(;i
{
//有个进位的
if(this.isCarry())
{
int tdata = this.data[i]+1;
if(tdata >=10) this.data[i] = tdata -10;
else
{
this.data[i] = tdata;
this.setCarry(false);
}
}
}
//对最高位益处检测
if(this.data[this.getDigit()-1] == 0)
{
int[] tdata = new int[this.getDigit()+1];
System.array(this.getData(), 0, tdata, 0, this.getDigit());
tdata[this.getDigit()] = 1;
this.setData(tdata);
}
}
}
其中代码段
//对最高位益处检测
if(this.data[this.getDigit()-1] == 0)
{
int[] tdata = new int[this.getDigit()+1];
System.array(this.getData(), 0, tdata, 0, this.getDigit());
tdata[this.getDigit()] = 1;
this.setData(tdata);
}
⑸ java中如何对较大的数字进行计算
不管是不是用JAVA，其实方法都一样，利用数组比如说长度为一千的数字，可以这个 int[] number = new int[1000];相加的思路是，首先两个数组的长度必须是一致，位数不同的话，前面补0，内存有点浪费，但是计算起来比较方便。然后让它们从0到最高位，每位进行相加并保存相应的位置上。最后一步是从0开始判断有没有大于10的数字，如果有就向前面进位（前一个加1，当前位减10），这样就可以。如果是相减，其实思路还是一样的，每位先相减，再判断是否有小于0的，如果有则向前面一位借1（前一位减1，当前位加10）如果是相乘，和上面一样，不过要注意的是进位的时候，不止进一位，比如5*6，就要向前进3位了（前一位加3，当前位减30）除就比较麻烦点，要涉及到精确度问题，得看实际需要 输出就更容易了，直接for循环数组 特别要注意的是，如果最高位有进位的时候，这个是比较容易出错的地方 思路在上面，如果实现不了请留言
⑹ java使用LinkedList进行大数相加，求指点。。。
public
static void main(String[] args) {
// TODO Auto-generated method stub
List<Integer> bigNumber =
new LinkedList<Integer>();
for(int i = 0; i <30; i++) {
bigNumber.add(7);
}
List<Integer> bigNumber1 =
new LinkedList<Integer>();
for(int i = 0; i < 30; i++) {
bigNumber1.add(6);
}
System.
out.println("bigNumber:"+bigNumber);
System.
out.println("bigNumber1:"+bigNumber1);
List<Integer> m = addMethod(bigNumber, bigNumber1);
for(int i = m.size()-1; i >=0; i--){ //因为是顺着放进去的，所以应该倒着取出来。
System.
out.print(m.get(i));
}
}
public static List<Integer> addMethod(List<Integer> a, List<Integer> b) {
List<Integer> sum =
new LinkedList<Integer>();
int ii = 0; //存储十位上的数
for(int i = 0; i < 30; i++) {
int temp;
if(ii > 0){
temp = a.get(i) + b.get(i) + ii;
//当十位上有数字是就应该加上
ii = 0;
}
else{
temp = a.get(i) + b.get(i);
}
if(temp >= 10) {
int u = temp%10;
int y = temp/10;
sum.add(u);
ii = y;
if(i == 29){ //当加到最后一位时，应该把十位也放进结果里
sum.add(ii);
}
}
else {
sum.add(temp);
}
}
return sum;
}
⑺ JAVA编程中“两个大整数求和”怎么编写
将大整数存入字符数组，按位相加。 给你写一段伪代码。
String a = "12389839843958394";
String b = "23445655234343";
char ac [] = a.toCharArray();
char bc [] = b.toCharArray();
这里要将数组ac 和bc 倒序排列，因为"123"转换后为{'1','2','3'} 高位在前，倒序是为了低位在前。这部分代码自己实现把。
char longc[];
char shortc[];
if (ac.length>=bc.length) {
longc=ac;
shortc=bc;
} else {
longc=bc;
shortc=ac;
}
下面做一个for循环，按位相加乘以10的i次方。就像小学学的列竖式子一样
int sum=0;
for (int i=longc.length;i<longc.length;i++) {
if (i<shortc.length) {
sum+=(longc[i]+shortc[i]-96)*Math.pow(10, i);
} else {
sum+=(longc[i]-48)*Math.pow(10, i);
}
}
其中字符相加的时候减48是将char 转换成int
⑻ java.求两个大数的精确加减法,a=
花了十分钟，亲手给你订制的，测试过了正确
下面给你贴出源代码
public class AddSub {
public static void main(String[] args) {
String a="";
String b="47";
int []pa=stringToInts(a);
int []pb=stringToInts(b);
String ans_add=add(pa, pb);
String ans_sub=sub(pb,pa);
System.out.println("相加结斗罩果是："+ans_add);
System.out.println("相减颂渣结果是："+ans_sub);
}
public static int[] stringToInts(String s){
int[] n = new int[s.length()];
for(int i = 0;i<s.length();i++){
n[i] = Integer.parseInt(s.substring(i,i+1));
}
return n;
}
public static String add(int []a,int []b){
StringBuffer sb=new StringBuffer();
int a_len= a.length-1;
int b_len=b.length-1;
int jinwei=0;//进位
while(a_len>=0||b_len>=0){
int temp=0;
if(a_len>野销悄=0&&b_len>=0){
temp=a[a_len]+b[b_len]+jinwei;
}else if(a_len>=0){
temp=a[a_len]+jinwei;
}else if(b_len>=0){
temp=b[b_len]+jinwei;
}
sb.append(temp%10+"");
jinwei=temp/10;
a_len--;b_len--;
}
return getNum(sb.reverse());
}
public static String sub(int []a,int []b){
StringBuffer sb=new StringBuffer();
boolean flag=false;//判断a是不是比b小
if(a.length<b.length){
int c[]=a;
a=b;b=c;
flag=true;
}
int a_len= a.length-1;
int b_len=b.length-1;
int jiewei=0;//借位
while(a_len>=0||b_len>=0){
int temp=0;
if(a_len>=0&&b_len>=0){
if((a[a_len]-jiewei)<b[b_len]){
temp=a[a_len]+10-b[b_len]-jiewei;
jiewei=1;
}else{
temp=a[a_len]-b[b_len]-jiewei;
}
}else if(a_len>=0){
temp=a[a_len]-jiewei;
jiewei=0;
}
sb.append(temp+"");
a_len--;b_len--;
}
if(flag){
return getNum(sb.append("-").reverse());
}
return getNum(sb.reverse());
}
//去掉最前面的0
public static String getNum(StringBuffer sb){
while(sb.length() > 1 && sb.charAt(0) == '0') {
sb.deleteCharAt(0);
}
return sb.toString();
}
}
⑼ java 两数相加 计算代码 给个答案呗
public class Operation{
public int operation(int a,int b){
return a+b;
}
}
这是简单计算两数方法，先创建这个对象然后调用其中operation这个方法，传输你要想要计算的参数就可以得到答案了如 new Operation().operation(1,3)得到答案4虽然没编译应该没问题