java大数加减乘除

package java1;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

public class BigInteger {

 private int[] val;
 private int sign; //nagetive sign ,1 表示是负数，0表示是正数
 
 
/**
 * 构造函数
 * */ 
 public BigInteger(String value){
  String valTemp=null;
  
   if(value.charAt(0)=='-')
    {
    sign=1;
    valTemp=value.substring(1);
    }
   else
   {
    sign=0;
    valTemp= value;
   }
   Pattern pattern = Pattern.compile("[0-9]*");       
   if(pattern.matcher(valTemp).matches() )
   {
    byte[] numberByte=makePositive(subtractZero(valTemp).getBytes());
    val=byteToInt(numberByte);
   }
   else
   {
    throw new NumberFormatException("Illegal digit");
   }
  
//   for(int i=0;i<val.length;i++)
//    System.out.print(val[i]);
//   System.out.println();
 }

 
 /**
  * 获取数值
  * */
 public String getBigIntegerValue(){
  //String returnValue=null;
  //去掉开头的0
  int index=val.length-1;
  for (int i=val.length-1;i>0;i--)
  {
   if(val[i]==0)
   {
    index=i-1;
   }
   else
    break;
  }
  int [] middleVlaue=makePositive(val,index);
  StringBuilder s= new StringBuilder();
  if (val.length>0){
    if(sign==1) s.append('-'); 
     for(int i=0;i<=middleVlaue.length-1;i++)
      s.append(middleVlaue[i]);  
   
       } 
   return s.toString();
       
 }
 

 /**
  * 加法
  * */
 public BigInteger add(BigInteger other){
  BigInteger bigResult= new  BigInteger("0");
  if(this.sign==other.sign)
  {
   bigResult.val= add(this.val,other.val);
   bigResult.sign=this.sign;
  }
  else
  {
  if(compare(this.val,other.val))
  {
   bigResult.sign=this.sign;
   bigResult.val=subtract(this.val,other.val);
  }
  else
  {
  bigResult.sign =other.sign;
  bigResult.val=subtract(other.val,this.val);
  }   
  }
  return bigResult ;
 }

 /**
  * 比较大小
  * */
 private boolean compare(int[] a ,int[] b)
 {
  int aLength=a.length;
  int bLength=b.length;
  boolean flag=true;
  if(aLength>bLength)
   return true;
  if(aLength<bLength)
   return false;
  else
  {
   for(int i=aLength-1;i>=0;i--)
   {
    if(a[i]==b[i])
      continue;
      if(a[i]>b[i])
      {
      // flag= true;
       break;
      }
       else
       {
         flag=false;
        break;
       }
       
   }
   return flag;
  }
  
 }
 
 
private int[] add(int[] a ,int[] b)
{
 int[] sumResult = null;
 if(a.length<=b.length)
 {
  sumResult=new int[b.length+1];
  for(int i=0;i<a.length;i++)
  {
  
    int middleValue=sumResult[i]+a[i]+b[i];
   if(middleValue>=10)
   {
      sumResult[i+1]=middleValue/10;
    sumResult[i]=middleValue%10;
   }
   else
    sumResult[i]=middleValue;
  }
      
 }
 else
  sumResult=add(b,a);
 for(int i=a.length;i<b.length;i++)
 {
  int middleValue=sumResult[i]+b[i];
  if(middleValue>=10)
  {
     sumResult[i+1]=middleValue/10;
    sumResult[i]=middleValue%10;
  }
  else
   sumResult[i]=middleValue;
 }
 
 return sumResult;   
}

private BigInteger subtract(BigInteger other){
 BigInteger bigResult= new  BigInteger("0");
 if(this.sign==other.sign)
 {
 if(this.compare(this.val, other.val))
 {
   bigResult.val=this.subtract(this.val, other.val);
   bigResult.sign=this.sign;
 }
 else
 {
   bigResult.val=this.subtract(other.val,this.val);
      bigResult.sign=(other.sign==0)?1:0;
 }
 }
 else
 {
  bigResult.sign=this.sign;
  bigResult.val=this.add(this.val, other.val);
 
 }
 
 return bigResult;
}

/**
 * 两个整形字符串相减,a>b
 * */
private int[] subtract(int[] a ,int[] b){
 int[] subractResult=new int[a.length];
 for(int i=0;i<b.length;i++)
 {
  int middleValue=subractResult[i]+a[i]-b[i];
  if(middleValue<0)
  {
   subractResult[i]=10-(Math.abs(middleValue)%10);
   //if(i<a.length-1)
      subractResult[i+1]=((Math.abs(middleValue)/10)+1)*(-1);}
  else
   subractResult[i]=middleValue;
 }
 for (int i=b.length;i<a.length;i++)
 {
  int middleValue=subractResult[i]+a[i];
  if(middleValue<0)
  {
   subractResult[i]=Math.abs(middleValue)%10;
   subractResult[i+1]=((Math.abs(middleValue)/10)+1)*(-1);
  }
  else
   subractResult[i]=middleValue;
 }
 return subractResult;
}
/**
 * 乘法
 * */
public BigInteger multiply(BigInteger other){
 BigInteger bigResult= new  BigInteger("0");
 if(this.sign==other.sign){
  bigResult.sign=this.sign;
 }
 else
  bigResult.sign=1;
  
 if(this.compare(this.val, other.val)){
   bigResult.val= multiply(this.val, other.val);}
   else
    bigResult.val= multiply( other.val,this.val); 
 
 return bigResult;
 
}
/**
 * 乘法
 * */
private int[] multiply(int[] a ,int [] b){
 int[] multiplyResult=new int[a.length+b.length];
   multiplyResult=multiply(a,b[0]);
 for(int i=1;i<b.length;i++)
  multiplyResult=add(multiply(a,b[i]*i*10),multiplyResult);
 return multiplyResult;
}

private int[] multiply(int[]a ,int b){
 int[] result=new int[a.length+1];
 for(int i=0;i<a.length;i++)
 {
  int midddleValue=result[i]+a[i]*b;
   if(midddleValue>=10){ 
    result[i]=midddleValue%10;
       result[i+1]=midddleValue/10;
   }else
  result[i]=midddleValue;
 }
 return result;
}

/**
 * 除法
 * */
public  BigInteger divide(BigInteger other){
 BigInteger divideResult=new BigInteger ("0");
  StringBuffer sbuffer= new  StringBuffer();
   if(other.val.length==1 && other.val[0]==0)
     {
    throw new ArithmeticException("the dividend can't be 0");
   
  }else{
   
   if(this.sign==other.sign)
    divideResult.sign=this.sign;
   else
    divideResult.sign=1;
   divideResult.val=this.divideArray(this.val,other.val);
  // int[] middleValue=this.divideArray(this.val,other.val);
   //divideResult.val=makePositive(middleValue,middleValue.length) ;
        
  return  divideResult;
  }

 
}
/**
 *
 * */
private int[] divideArray(int[] a,int[] b){
 //StringBuffer sb= new StringBuffer();
 int[] remainValue=new int[a.length];
   int[] resultValue = new int[a.length+3];
 //长度大于等于被除数长度
    if(this.compare(a,b)){
     int[] middleValue=new int[a.length];
      middleValue=subIntArray(a,(a.length-b.length),b.length);
 for(int i=a.length-b.length;i>=0;i--){
  // a>b
  int[] addDivide=new int[1];
  int[] middleValue1=this.subtractZero(middleValue);
  if(this.compare(middleValue1,b)){
   List list=divide(middleValue1,b); 
   remainValue=(int[]) list.get(1);
    resultValue[i]=resultValue[i]+(Integer)list.get(0);
   if(i>=1)
   {
   addDivide[0]=a[i-1];
   middleValue=subtractZero(this.add(multiply(remainValue,10),addDivide)) ;
   }
  }
  else
  {
   if(i>=1)
    {
       addDivide[0]=a[i-1];
       int[] mulValu=multiply( middleValue,10);
     int[]  middleValue2=this.add(mulValu,addDivide) ;
     middleValue=middleValue2;
    resultValue[i]=0;
    }
  }
 }
    }
    else
  {
     resultValue[0]=0;
 }
 return resultValue;
 
}

 

/**
 * a和b的长度一样
 * */
private List divide(int[] a,int[] b)
{
 int[] zeroArray={0};
 int[] remainValue=a;
 List list = new ArrayList();
 int divideResult=0;
  for(int i=0;i<=9;i++){
   if(compare(a,b)){
    remainValue=this.subtract(remainValue,b);
    int[] valueTemp=this.subtractZero(remainValue);
       if(!this.compare(valueTemp,b))  
       {
        //System.out.println("i的值为："+i);
        divideResult=i+1;
        break;
       }
   }
   else{
    divideResult=0;
   }
    
   }
  list.add(divideResult);
  list.add(remainValue);
  return list ;
}

private int[] subIntArray(int[] a,int index,int length)
{
 int[] middleValue=new int[length];
 for(int i=index;i<index+length;i++)
 {
   middleValue[i-index]=a[i];
 }
  return middleValue ;
}

/**
 * 反转字符数组
 * */ 
private byte[] makePositive(byte[] a)
{
  byte [] result = new byte[a.length];
 
  for(int i=a.length-1;i>=0;i--)
   result[a.length-i-1]=a[i];
  return result;
 //  val[i]=numberByte[i]& 0xff;
}

/**
 * 反转字符数组
 * index=a.length-1
 * */ 
private int[] makePositive(int[] a,int index)
{
  int [] result = new int[index+1];
 
  for(int i=index;i>=0;i--)
   result[index-i]=a[i];
  return result;
 //  val[i]=numberByte[i]& 0xff;
}
/**
 * 字节转换为数字
 * */
private int[]  byteToInt(byte[] a){
 int[] result=new int[a.length];
 for (int i=0;i<a.length;i++)
 {
  result[i]=a[i]-48;
 }
 return result;
}
/**
 * 数字转换为字节
 * */
public static  byte[]  intToByte(int[] a){
 byte[] result=new byte[a.length];
 for (int i=0;i<a.length;i++)
  result[i]= (byte) a[i];
 return result;
}

/**
 * 去掉头部的0
 *
 * */
private String subtractZero(String value){
int flag=0;   
for(int i=0;i<value.length();i++)
{
 if( value.charAt(i)=='0')
  flag=flag+1;
 else
  break;
 
}
if(flag==value.length())
  return "0";
else
return value.substring(flag);
}

/**
 * 去除整型数组中最高位的0
 * */
private int[] subtractZero(int[] a)
{
 //int[] resultIntArray;
 int length=a.length;
  for(int i=a.length-1;i>=0;i--)
  {
   if(a[i]!=0)
   {
    length=i;
    break;
   }
  }
  if(a.length==length)
  {
   int[] resultIntArray={0};
   return resultIntArray;
  }
  else
  {
   int[] resultIntArray= new int[length+1]; 
   for(int i=0;i<=length;i++)
    resultIntArray[i]=a[i];
   return resultIntArray;
  }
  
}

 

public static void main(String args[]){
 BigInteger a=new BigInteger("109");
 BigInteger b=new BigInteger("5");
 
 BigInteger c=a.divide(b);
 System.out.println(c.getBigIntegerValue());
       c=a.add(b);
 System.out.println(c.getBigIntegerValue());
 c=a.subtract(b);
 System.out.println(c.getBigIntegerValue());
 c=a.multiply(b);
 System.out.println(c.getBigIntegerValue());
 
}

}