本代码自己编写，功能基本实现，还可以继续优化。
一、算法思想：
分治的思想解决问题。
a.对问题进行分析，划分成多个子问题。
b.解决子问题。
c.合并自子问题给出问题的解。
数据结构：数组。
1.加法：
（1）补齐字符串长度：字符串较小的左边补0，使得两个字符串长度相等；
（2）截取字符串：截取字符串的每一位，存储到数组，数组的低位对应数字的高位。
（3）每一位对应相加：设置进位标志位，初始值为0，从低位开始相加。用数组保存每一位的结果。
（4）输出结果。
2.减法：
（1）找出较大的数：通过比较字符串的长度，找出最大数。有三种可能，第一个较长，第二个较长，两者相等。若第一个较长则结果标志位为正；若第二个较长怎结果标志位为负；
若相等则从最高位依次比较大小，找出较大值和较小值，设置正负标志位，若两者相等怎结果为0；
（2）截取字符串：截取每一位的字符串，存储到数组。
（3）相减：大数减小数，设置借位标志位。
（4）根据结果标志位，输出结果
3.乘法：
（1）求出被乘数和乘数的长度为m，n。 ? ?12345（被乘数）*45678（乘数）截取字符串到数组。
（2）将问题分解为n个子问题，每个子问题是被乘数乘以乘数的每一位。也即做乘数大小次相加。
（3）解的结构是个一维字符串数组，第一行表示第一次相乘的结果，第二行表示第二次相乘的结果
（4）将结果每一行的结果错位再相加。得到问题的解决办法。
4.阶乘：
（1）1000！=Mul(Mul(Mul(str1,str2),str3),str4)......
工具类：各种操作方法
public class ToolsImpl implements ITools {
public int absolute(int A,int B) {
// TODO Auto-generated method stub
if(A-B<0) return B-A;
else return A-B;
}
public int compareString(String A,String B) {
// TODO Auto-generated method stub
//return 0表示相等;return 1表示A>B;return 2表示A<B
int lenA=A.length();
int lenB=B.length();
int tempA,tempB;//将一个字符转换为整形存储
int result;
if(lenA>=lenB){
if(lenA==lenB){
for(int i=0;i<lenA;i++){
tempA=Integer.parseInt(A.substring(i,i+1));
tempB=Integer.parseInt(B.substring(i,i+1));
if(tempA>tempB){
result= 1;
break;
}
if(tempA<tempB){
result= 2;
break;
}
}
result= 0;
}
else result= 1;
}
else result= 2;
return result;
}
@Override
public String insertZero(String A,int n) {
// TODO Auto-generated method stub
for(int i=0;i<n;i++){
A="0"+A;
}
return A;
}
@Override
public int FirstNumberPositon(int[] A) {
// TODO Auto-generated method stub
int length=A.length;
int i;
for(i=0;i<length;i++){
if(A[i]!=0) return i;
}
return 0;
}
@Override
public Service propertiesFunction(String operate) {
// TODO Auto-generated method stub
Class<?> temp=null;
Service service=null;
ResourceBundle rb=ResourceBundle .getBundle("main.BigData");
try {
temp=Class.forName(rb.getString(operate));
service=(Service)temp.newInstance();
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return service;
}
@Override
public String rightInsertZero(String A,int n) {
// TODO Auto-generated method stub
for(int i=0;i<n;i++){
A+="0";
}
return A;
}
@Override
public String inc(String A) {
// TODO Auto-generated method stub
Add sub=new Add();
String result=sub.getResult(A,"1");
return result;
}
}
加法：
public String getResult(String firstNumber,String secondNumber) {
// TODO Auto-generated method stub
String result="";
int lenFirst=firstNumber.length();
int lenSecond=secondNumber.length();
String Max,Min;
int length;
//获取长值和短值
if(lenFirst>lenSecond){
Max=firstNumber;
Min=secondNumber;
length=lenFirst;
}
else {
Max=secondNumber;
Min=firstNumber;
length=lenSecond;
}
//短值补零
ITools tools=new ToolsImpl();
for(int i=0;i<tools.absolute(lenFirst,lenSecond);i++){
Min="0"+Min;
}
//获取每一个字符
int arryA[]=new int[length];
int arryB[]=new int[length];
for(int i=0;i<length;i++){
arryA[i]=Integer.parseInt(Max.substring(i,i+1));
arryB[i]=Integer.parseInt(Min.substring(i,i+1));
}
//计算和
int arryC[]=new int[length];
int flag=0;
int temp;
for(int i=length-1;i>=0;i--){
temp=arryA[i]+arryB[i]+flag;
if(temp>=10){
flag=1;
arryC[i]=temp-10;
}else{
flag=0;
arryC[i]=temp;
}
}
if(flag==1){
//System.out.print("1");
result+="1";
}
for(int i=0;i<length;i++){
// System.out.print(arryC[i]);
result+=arryC[i];
}
//System.out.println();
//System.out.println(result);
return result;
}
}
减法：
public String getResult(String firstNumber,String secondNumber) {
int lenFirst=firstNumber.length();
int lenSecond=secondNumber.length();
String result="";
String Max,Min;
int compareResult;//接收比较结果=><
int length;//最大数的长度
int signFlag=1;//标记位，标记结果为0还是1；
//比较大小
ITools tools=new ToolsImpl();
compareResult=tools.compareString(firstNumber,secondNumber);
//小数插0(两个说不相等且位数相同，可以优化(就是不在调用插入函数))
if(compareResult==0){
result+="0";
return result;
}else if(compareResult==1){
Min=tools.insertZero(secondNumber,lenFirst-lenSecond);
Max=firstNumber;
signFlag=1;
}else ? if(compareResult==2){
Min=tools.insertZero(firstNumber,lenSecond-lenFirst);
Max=secondNumber;
signFlag=0;
}else {
System.out.println("比较结果有误！");
return null;
}
System.out.println("加0处理后的结果：");
System.out.println("Max="+Max+";Min="+Min);
length=Max.length();
int arryA[]=new int[length];//将字符串的每一位转化为整形，存储字符串的每一位
int arryB[]=new int[length];
for(int i=0;i<length;i++){
arryA[i]=Integer.parseInt(Max.substring(i,i+1));
}
int arryC[]=new int[length];//存储结果
int flag=0;
int temp;
for(int i=length-1;i>=0;i--){
temp=arryA[i]-arryB[i]-flag;
if(temp>=0){
arryC[i]=temp;
} else {
arryC[i]=temp+10;
flag=1;
}
}
if(signFlag==1){
for(int i=tools.FirstNumberPositon(arryC);i<length;i++){
result+=arryC[i];
}
}else{
result+="-";
for(int i=tools.FirstNumberPositon(arryC);i<length;i++){
result+=arryC[i];
}
}
return result;
}
}
乘法：
public String getResult(String firstNumber,String secondNumber) {
// TODO Auto-generated method stub
int lenFir=firstNumber.length();
int lenSec=secondNumber.length();
//定义数据结构
int arrayB[]=new int[lenSec];
String arrayC[]=new String[lenSec];
for(int i=0;i<lenSec;i++){//结果集的初始化
arrayC[i]="0";
}
//截取字符串
for(int i=0;i<lenSec;i++){
arrayB[i]=Integer.parseInt(secondNumber.substring(i,i+1));
}
//做乘法
Add add=new Add();
for(int i=lenSec-1;i>=0;i--){
//第一次：第一个字符串乘以第二个字符串的最后一位。用加法做
for(int j=0;j<arrayB[i];j++){
arrayC[lenSec-1-i]=add.getResult(firstNumber,arrayC[lenSec-1-i]);
}
}
//已经获得子问题结果集，整合成问题的解→第n行右边补n个0，相加
String result="";
ITools tools=new ToolsImpl();
for(int i=0;i<lenSec;i++){
result=add.getResult(tools.rightInsertZero(arrayC[i],i),result);
}
return result;
}
}
阶乘：
public String getResult(String firstNumber,String secondNumber) { // TODO Auto-generated method stub String resultA="2"; String result="1"; Mul mul=new Mul(); ITools tools=new ToolsImpl(); if(firstNumber.equals("0")||firstNumber.equals("1")) return "1"; while(!resultA.equals(firstNumber)){ result=mul.getResult(result,resultA ); resultA=tools.inc(resultA); } result=mul.getResult(result,firstNumber); return result; } }
