Java常用數字工具類大數乘法、加法、減法運算（2）

更新時間：2017年05月09日 16:37:26 作者：龍軒

這篇文章主要為大家詳細介紹了Java常用數字工具類，大數乘法、加法、減法運算，具有一定的參考價值，感興趣的小伙伴們可以參考一下

上篇分享了一下數字轉漢字的小功能，這里再分享一下大數相乘、相加、相減的功能。其他的不做過多的鋪墊了，我先講一下各個功能的計算原理。

Ⅰ. 乘法運算

為什么先說乘法運算——因為我先做了乘法運算。其實思路也是很多的，但是最終我參考了網絡上的一種計算方案，然后做了很多的修改。感覺這個在思路上應該是比較簡單的。

簡單點說：把數拆分成整數小數分別進行乘法運算，然后將結果放入一個特定長度的數組中，在放入是要計算存放的偏移位置，最后再對這個進行處理（進位、標記等），得到最終的結果。
是不是有點暈。請我詳細說一下吧：

首先還得把數都拆成整數+小數，然后采用的是（x1+x2）（y1+y2）=x1y1+x1y2+x2y1+x2y2。這種方式來計算的，這樣來算，都變成了整數的運算了。要簡單很多。但是4個結果怎么累加起來計算呢，這就是第二步。
要申明一個int數組，長度=整數長度和+小數長度和+1（小數點占1位）。通過實驗，我們可以看到任意2個整數相乘結果都不會超過這2個數的長度和。
人為計算乘法的時候就是按右向左一位一位的計算的（低位對齊），所以為了對齊低位，我們將整數和小數全部反轉，并且轉化為char數組，方便運算。然后進行4次乘法。
按位進行乘法運算，采用雙層for循環(huán)完成這個操作。這里最為天才的idea就是——不進位。當然必須得弄清楚整數相乘放在數組的哪些個位置、小數相乘存放的開始位置，以及整數和小數相乘結果存放的開始位置。
處理結果集合，將>=10的做進位處理。
這一步也是很有才的想法——對小數點位置進行標記，而不是直接替換成“.”（int數組也不能直接設定(/ □ \)）。
有了第6步的想法，就有了第7步的做法，處理整數部分頭部的0和小數部分末尾的0，都是無效數字，這里同樣采用標記的方式來處理
最后將結果集合進行反轉輸出，遇到小數點標記和無效0標記直接替換和跳過。

這就是基本的思路了。后面又再次基礎上加上了負數的判斷、數字格式的判斷等，自己看注釋就可以明白了。
代碼如下：

//標記為小數點 
private static final int DOT=-99; 
//標記為無效數字 
private static final int INVALID=-100; 
 
/** 
 * 大數乘法 
 * 
 * @param a  第一個數 
 * @param b  第二個數 
 * @return  最終結果 
 */ 
public static String multiply(String a, String b){ 
  //檢查數字格式 
  checkNum(a); 
  checkNum(b); 
 
  //標記最終結果是否為負值 
  boolean minus=false; 
 
  //判斷是否有帶著-號 
  if(a.startsWith("-") || b.startsWith("-")){ 
    //判斷是否全帶著-號 
    if(a.startsWith("-") && b.startsWith("-")){ 
    }else{ 
      //只有1個帶著-號，則結果為負值 
      minus=true; 
    } 
    if(a.startsWith("-")){ 
      a = a.substring(1); 
    } 
    if(b.startsWith("-")){ 
      b = b.substring(1); 
    } 
  } 
 
  //獲取a,b的整數和小數部分 
  String a_int = getInt(a); 
  String a_fraction = getFraction(a); 
  String b_int = getInt(b); 
  String b_fraction = getFraction(b); 
 
  //計算小數部分的總長度 
  int len_fraction = a_fraction.length() +b_fraction.length() ; 
 
  //a,b兩個數乘積的最大位數不會超過總位數之和+小數點（1位） 
  int len = len_fraction +a_int.length()+b_int.length()+1; 
 
  //創(chuàng)建結果數組 
  int[] result = new int[len];//默認全為0 
 
  //為了方便計算，去掉小數點（最后在結果中加上小數點） 
  //并將高低位對調(反轉是為了低位對齊)，最終轉化為char數組 
  char[] s_a_int = reverseStr(a_int); 
  char[] s_a_fraction = reverseStr(a_fraction); 
  char[] s_b_int = reverseStr(b_int); 
  char[] s_b_fraction = reverseStr(b_fraction); 
 
  //將a、b都拆分成整數+小數，然后 
  //采用（x1+x2）（y1+y2）=x1y1+x1y2+x2y1+x2y2公式，分別計算乘積 
  multiply(s_a_int, s_b_int, len_fraction, result); 
  multiply(s_a_int, s_b_fraction, (len_fraction-s_b_fraction.length), result); 
  multiply(s_b_int, s_a_fraction, (len_fraction-s_a_fraction.length), result); 
  multiply(s_a_fraction, s_b_fraction, 0, result); 
 
  // 處理結果集合，如果是大于10的就向前一位進位，本身進行除10取余 
  accumulateResultArrays(result); 
 
  //標記小數點位置 
  markDot(len_fraction, result); 
 
  //切掉無用的0 
  cutUnusedZero(len_fraction, result); 
 
  //然后將數據反轉 
  return (minus?"-":"") + reverseResult(result); 
} 
 
/** 
 * 反轉字符串，并轉化為數組 
 * 
 * @param s    原字符串 
 * @return 
 */ 
private static char[] reverseStr(String s) { 
  return new StringBuffer(s).reverse().toString().toCharArray(); 
} 
 
/** 
 * 計算2個數的每一位的乘積，放入到對應的結果數組中（未進位） 
 * 
 * @param a  第一個數 
 * @param b  第二個數 
 * @param start  開始放入的偏移位置 
 * @param result  結果數組 
 */ 
private static void multiply(char[] a, char[] b, int start , int[] result){ 
  // 計算結果集合 
  for (int i = 0; i < a.length; i++) { 
    for (int j = 0; j < b.length; j++) { 
      result[i + j + start] += (int) (a[i] - '0') * (int) (b[j] - '0'); 
    } 
  } 
} 
 
/** 
 * 累加每一位，超過10則然后進位 
 * 
 * @param result  結果數組 
 */ 
private static void accumulateResultArrays(int[] result) { 
  for (int i = 0; i < result.length; i++) { 
    if (result[i] >= 10) { 
      result[i + 1] += result[i] / 10; 
      result[i] %= 10; 
    } 
  } 
} 
 
/** 
 * 標記小數點位置 
 * 
 * @param len_fraction  小數長度 
 * @param result  結果數組（反轉的） 
 */ 
private static void markDot(int len_fraction, int[] result) { 
  if(len_fraction>0){ 
    //標記小數點位置 
    for (int i = result.length-1 ; i > len_fraction; i--) { 
      result[i] = result[i-1]; 
    } 
    result[len_fraction]=DOT;//標記小數點位置 
  } 
} 
 
/** 
 * 去掉不必要的0（包括整數最前面的和小數最后面的0） 
 * 
 * @param len_fraction  小數長度 
 * @param result    結果數組 
 */ 
private static void cutUnusedZero(int len_fraction, int[] result) { 
  //去掉小數部分不必要的0 
  boolean flag_0_fraction = true;//標記一直是0 
  for (int i =0; i< len_fraction; i++) { 
    if(flag_0_fraction && result[i]==0){ 
      result[i]=INVALID;//為0時標記為無效 
    }else{ 
      flag_0_fraction=false; 
      break; 
    } 
  } 
 
  //去掉整數部分的0 
  boolean flag_0_int=true; 
  for (int i =result.length-1; i > len_fraction || (len_fraction==0 && i==0); i--) { 
    if(flag_0_int && result[i]==0){ 
      result[i]=INVALID;//為0時標記為無效 
    }else{ 
      flag_0_int=false;//遇到不為0時，停止。 
      break; 
    } 
  } 
  if(flag_0_int){//整數部分全為0 
    result[len_fraction+1]=0; 
    if(flag_0_fraction){//同時，小數部分也全為0 
      result[len_fraction]=INVALID;//不需要小數點了，所以置為無效 
    } 
  }else{//整數部分不為0 
    if(flag_0_fraction && len_fraction>0){//小數部分全為0 
      result[len_fraction]=INVALID;//不需要小數點了，所以置為無效 
    } 
  } 
} 
 
/** 
 * 反轉結果，替換小數點，跳過無效的0 
 * 
 * @param result    結果數組 
 * @return 
 */ 
private static String reverseResult(int[] result) { 
  //反轉 
  StringBuffer sb = new StringBuffer(); 
  for (int i = result.length - 1; i >= 0; i--) { 
    if(result[i]>INVALID){ 
      sb.append(result[i]==DOT ? "." : result[i]); 
    } 
  } 
  return sb.toString(); 
}

我們繼續(xù)說第二個。

Ⅱ. 加法運算

有了上面的思路做鋪墊，下面的加法和減法基本上都可以秒懂了。負數及數字格式的判斷就直接略過了。直接說最基本的思路。

前兩步同乘法運算。拆分整數+小數，聲明一個int數組存放結果。長度為a b整數最大的長度+1+小數最大長度+1（小數點位）。因為加法最多位數比最大長度大1，所以有一個+1。
結果是整數和+小數和，整數要低位對齊，所以要反轉，小數則不用反轉。
用一個for循環(huán)來計算2個整數或者小數的和，同樣不進位。
剩下的同乘法4-8步。

代碼放在最后看吧。接著來說說減法。

Ⅲ. 減法運算

其實減法跟加法在代碼上看，更類似。詳細說一下：（忽略負數及數字格式的判斷）

前三步同加法運算。拆分整數+小數，聲明一個int數組存放結果。長度為a b整數最大的長度+小數最大長度+1（小數點位）。結果是整數差+小數差。
還是用一個for循環(huán)計算2個數的差，這里不是不進位了，而是不借位。
處理結果結合跟加法和乘法不一樣，加法和乘法都是進位，這里是借位，所以處理不太一樣。
剩下同加法。

具體代碼如下：

/** 
 * 大數加法 
 * 
 * @param a  第一個數 
 * @param b  第二個數 
 * @return  最終結果 
 */ 
public static String add(String a, String b){ 
  //檢查數字格式 
  checkNum(a); 
  checkNum(b); 
 
  //標記最終結果是否為負值 
  boolean minus=false; 
 
  //判斷是否有帶著-號 
  if(a.startsWith("-") || b.startsWith("-")){ 
    //判斷是否全帶著-號 
    if(a.startsWith("-") && b.startsWith("-")){ 
      //2個都帶著-號，結果肯定為負值 
      minus=true; 
      if(a.startsWith("-")){ 
        a = a.substring(1); 
      } 
      if(b.startsWith("-")){ 
        b = b.substring(1); 
      } 
    }else{ 
      //如果只有一個是負值，則調用減法來完成操作 
      if(a.startsWith("-")){//a是負數 
        a = a.substring(1); 
        return subduct(b, a); 
      }else{ 
        b = b.substring(1); 
        return subduct(a, b); 
      } 
 
    } 
  } 
 
  //獲取a,b的整數和小數部分 
  String a_int = getInt(a); 
  String a_fraction = getFraction(a); 
  String b_int = getInt(b); 
  String b_fraction = getFraction(b); 
 
  //計算小數部分最大長度 
  int len_fraction = Math.max(a_fraction.length(), b_fraction.length()); 
 
  //計算整數部分最大長度 
  int len_int = Math.max(a_int.length(), b_int.length())+1; 
 
  //a,b兩個數整數最大長度和小數最大長度之和+小數點（1位） 
  int len = len_fraction + len_int+1; 
 
  //創(chuàng)建結果數組 
  int[] result = new int[len];//默認全為0 
 
  //為了方便計算，去掉小數點（最后在結果中加上小數點） 
  //將【整數部分】高低位對調(反轉是為了低位對齊)，最終轉化為char數組 
  //小數部分不用調整 
  char[] s_a_int = reverseStr(a_int); 
  char[] s_b_int = reverseStr(b_int); 
  char[] s_a_fraction = a_fraction.toCharArray(); 
  char[] s_b_fraction = b_fraction.toCharArray(); 
 
  //采用整數+整數，小數+小數的方式運算 
  add(s_a_int, s_b_int, len_fraction, result); 
  add(s_a_fraction, s_b_fraction, 1-len_fraction, result); 
 
  // 處理結果集合，如果是大于10的就向前一位進位，本身進行除10取余 
  accumulateResultArrays(result); 
 
  //標記小數點位置 
  markDot(len_fraction, result); 
 
  //切掉無用的0 
  cutUnusedZero(len_fraction, result); 
 
  //然后將數據反轉 
  return (minus ? "-" : "")+reverseResult(result); 
} 
 
/** 
 * 計算2個數的每一位的和，放入到對應的結果數組中（未進位） 
 * 
 * @param a  第一個數 
 * @param b  第二個數 
 * @param start  開始放入的偏移位置 
 * @param result  結果數組 
 */ 
private static void add(char[] a, char[] b, int start , int[] result){ 
  char[] c=null; 
  //保證a是位數多的，如果b長度大于a，則交換a，b 
  if(b.length>a.length){ 
    c=a; 
    a=b; 
    b=c; 
  } 
  // 計算結果集合，a的位數>=b的位數 
  int i = 0, j=0; 
  for (; i < a.length && j< b.length; i++,j++) { 
    result[Math.abs(i + start)] += (int) (a[i] - '0') + (int) (b[j] - '0'); 
  } 
  //如果a沒有處理完畢，直接把a剩下的值賦值給結果數組即可 
  for (; i < a.length; i++) { 
    result[Math.abs(i + start)] += (int) (a[i] - '0'); 
  } 
  if(c!=null){//如果交換過，則再交換回來 
    c=a; 
    a=b; 
    b=c; 
  } 
  c=null; 
} 
 
/** 
 * 大數減法 
 * 
 * @param a  第一個數 
 * @param b  第二個數 
 * @return  最終結果 
 */ 
public static String subduct(String a, String b){ 
  //檢查數字格式 
  checkNum(a); 
  checkNum(b); 
 
  //標記最終結果是否為負值 
  boolean minus=false; 
 
  //判斷是否有帶著-號 
  if(a.startsWith("-") || b.startsWith("-")){ 
    //判斷是否全帶著-號 
    if(a.startsWith("-") && b.startsWith("-")){ 
      //2個都帶著-號 
      if(a.startsWith("-")){ 
        a = a.substring(1); 
      } 
      if(b.startsWith("-")){ 
        b = b.substring(1); 
      } 
      return subduct(b, a); 
    }else{ 
      //如果只有一個是負值，則調用加法來完成操作 
      if(a.startsWith("-")){//a是負值，b是非負值 
        return add(a, "-"+b);//2個負值的加法運算 
      }else{//b是負值 
        b = b.substring(1); 
        return add(a, b);//2個正值的加法運算 
      } 
    } 
  } 
 
  //獲取a,b的整數和小數部分 
  String a_int = getInt(a); 
  String a_fraction = getFraction(a); 
  String b_int = getInt(b); 
  String b_fraction = getFraction(b); 
 
  boolean isSame = false; 
  //判斷大小 
  if(b_int.length()>a_int.length()){ 
    //如果b>a 
    return "-"+subduct(b, a); 
  }else if(b_int.length()==a_int.length()){ 
    char[] s_a = a_int.toCharArray(); 
    char[] s_b = b_int.toCharArray(); 
    for (int i = 0; i < s_a.length; i++) { 
      if(s_b[i]>s_a[i]){ 
        minus=true; 
        isSame=false; 
        break; 
      }else if(s_b[i]<s_a[i]){ 
        isSame=false; 
        break; 
      }else{ 
        isSame = true; 
      } 
    } 
    if(isSame){//整數部分全部相同，對比小數部分 
      s_a = a_fraction.toCharArray(); 
      s_b = b_fraction.toCharArray(); 
      for (int i = 0; i < Math.min(s_a.length, s_b.length); i++) { 
        if(s_b[i]>s_a[i]){ 
          minus=true; 
          isSame=false; 
          break; 
        }else if(s_b[i]<s_a[i]){ 
          isSame=false; 
          break; 
        }else{ 
          isSame = true; 
        } 
      } 
      if(isSame){//前部分全相同 
        if(s_b.length>s_a.length){//前部分全相同，b小數位數多,則 b>a 
          return "-"+subduct(b, a); 
        }else if(s_b.length == s_a.length){ 
          return "0"; 
        } 
      }else if(minus){//如果b>a 
        return "-"+subduct(b, a); 
      } 
    } 
  } 
 
 
  //計算小數部分最大長度 
  int len_fraction = Math.max(a_fraction.length(), b_fraction.length()); 
 
  //計算整數部分最大長度 
  int len_int = Math.max(a_int.length(), b_int.length()); 
 
  //a,b兩個數整數最大長度和小數最大長度之和+小數點（1位） 
  int len = len_fraction + len_int+1; 
 
  //創(chuàng)建結果數組 
  int[] result = new int[len];//默認全為0 
 
  //為了方便計算，去掉小數點（最后在結果中加上小數點） 
  //將【整數部分】高低位對調(反轉是為了低位對齊)，最終轉化為char數組 
  //小數部分不用調整 
  char[] s_a_int = reverseStr(a_int); 
  char[] s_b_int = reverseStr(b_int); 
  char[] s_a_fraction = a_fraction.toCharArray(); 
  char[] s_b_fraction = b_fraction.toCharArray(); 
 
  //采用整數+整數，小數+小數的方式運算 
  subduct(s_a_int, s_b_int, len_fraction, result); 
  subduct(s_a_fraction, s_b_fraction, 1-len_fraction, result); 
 
  // 處理結果集合，如果是大于10的就向前一位進位，本身進行除10取余 
  subductResultArrays(result); 
 
  //標記小數點位置 
  markDot(len_fraction, result); 
 
  //切掉無用的0 
  cutUnusedZero(len_fraction, result); 
 
  //然后將數據反轉 
  return (minus ? "-" : "")+reverseResult(result); 
} 
 
/** 
 * 計算2個數的每一位的差，放入到對應的結果數組中（未進位） 
 * 
 * @param a  第一個數 
 * @param b  第二個數 
 * @param start  開始放入的偏移位置 
 * @param result  結果數組 
 */ 
private static void subduct(char[] a, char[] b, int start , int[] result){ 
  // 計算結果集合，a的位數>=b的位數 
  int i = 0, j=0; 
  for (; i < a.length && j< b.length; i++,j++) { 
    result[Math.abs(i + start)] +=((int) (a[i] - '0') - (int) (b[j] - '0')); 
  } 
  //如果a沒有處理完畢，直接把a剩下的值賦值給結果數組即可 
  for (; i < a.length; i++) { 
    result[Math.abs(i + start)] +=((int) (a[i] - '0')); 
  } 
  //如果a沒有處理完畢，直接把a剩下的值賦值給結果數組即可 
  for (; i < b.length; i++) { 
    result[Math.abs(i + start)] +=-((int) (b[i] - '0')); 
  } 
} 
 
/** 
 * 檢查每一位，小于0（不含標記的小數點未和無效的0）則然后向高位借位。 
 * 
 * @param result  結果數組 
 */ 
private static void subductResultArrays(int[] result) { 
  for (int i = 0; i < result.length-1; i++) { 
    if (result[i] < 0 && result[i]>DOT) { 
      result[i + 1]--; 
      result[i] += 10; 
    } 
  } 
}

寫個main方法測試一下吧：

public static void main(String[] args) { 
  String a = "9213213210.4508"; 
  String b = "12323245512512100.4500081"; 
  String r = multiply(a, b); 
  System.out.println(a+"*"+b+"="+r); 
  String r1 = add(a, b); 
  System.out.println(a+"+"+b+"="+r1); 
  String r2 = subduct(a, b); 
  System.out.println(a+"-"+b+"="+r2); 
}

測試結果如下：

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章:

SpringBoot之自定義Filter獲取請求參數與響應結果案例詳解
這篇文章主要介紹了SpringBoot之自定義Filter獲取請求參數與響應結果案例詳解,本篇文章通過簡要的案例,講解了該項技術的了解與使用,以下就是詳細內容,需要的朋友可以參考下
2021-09-09
SpringBoot事件發(fā)布和監(jiān)聽詳解
今天去官網查看spring boot資料時，在特性中看見了系統的事件及監(jiān)聽章節(jié),所以下面這篇文章主要給大家介紹了關于SpringBoot事件發(fā)布和監(jiān)聽的相關資料,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下
2021-11-11
Java使用橋接模式實現開關和電燈照明功能詳解
這篇文章主要介紹了Java使用橋接模式實現開關和電燈照明功能,較為詳細的講述了橋接模式的概念、原理并結合實例形式分析了Java使用橋接模式實現開關和電燈照明功能相關操作步驟與注意事項,需要的朋友可以參考下
2018-05-05
Java實現讀取不同格式的文件的示例詳解
在?Java?開發(fā)中,我們經常需要讀取不同類型的文件,包括?Excel?表格文件、"doc"?等,本文將介紹如何使用?Java?讀取這些不同類型的文件,需要的可以參考下
2024-01-01
Java Web三層架構的配置詳解
這篇文章主要介紹了Java Web三層架構的配置方法,需要的朋友可以參考下
2014-10-10
詳解Spring簡單容器中的Bean基本加載過程
本篇將對定義在 XMl 文件中的 bean，從靜態(tài)的的定義到變成可以使用的對象的過程，即 bean 的加載和獲取的過程進行一個整體的了解
2017-05-05
Java讀寫txt文件時防止中文亂碼問題出現的方法介紹
這篇文章主要介紹了Java讀寫txt文件時防止中文亂碼問題出現的方法,同時需要注意系統默認的文本保存編碼的設置,需要的朋友可以參考下
2015-12-12
Java單例模式、饑餓模式代碼實例
這篇文章主要介紹了Java單例模式、饑餓模式代碼實例,本文直接給出代碼實例,需要的朋友可以參考下
2015-05-05
解決IDEA鼠標點擊光標變大問題
這篇文章主要介紹了解決IDEA鼠標點擊光標變大問題，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
2021-02-02
IDEA Project不顯示/缺失文件問題及解決
在側邊欄的project模式下,如果發(fā)現缺少部分文件,可以嘗試關閉項目,打開項目所在目錄,刪除目錄下的.idea文件夾,然后重新打開項目即可解決
2024-11-11