⑴ 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雖然沒編譯應該沒問題