please help me with this java design for data structures the language is java

Question

Problem. Design a data structure to support operations on positive integers with many digits.

The data type int in Java has a limited range from -2³¹ = -2147483648 to 2³¹ - 1 = 2147483647, about 2.1 billion. 

The data type long has a larger limited range from -2⁶³ = -9223372036854775808 to 2⁶³ - 1 = 9223372036854775807, about 9.2 quintillion.

The purpose of this final is to design a class to support some arithmetic operations on positive integers with many digits. The operations are addition, subtraction, multiplication and exponentiation. For simplicity for the

subtraction of two big positive integers a and b, a - b, assume a ≥ b and for exponentiation of aⁿ, assume n is a positive int.

Your abstract data type for big positive integers must use the ArrayList< E > class found in the java.util package. You cannot use the BigInteger class of the java.math package. 

Your design is a detailed essay that uses proper English in which you describe the development of your class to support some arithmetic operations on big positive integers with many digits. Your essay must describe in detail the development of a class for big positive integers, called BigPositiveInt. It must also describe the class called Main that contains the required method main() with statements to test the methods of the class BigPositiveInt.

For the class BigPositiveInt you must describe in detail its attributes, its constructors and its methods. You must describe in detail the algorithm for each constructor and for each method of the class with English paragraphs. Then you must provide pseudo code for your algorithm. You must include a simulation of each algorithm for an arithmetic operation with small arguments and a base of 10.

I suggest using the usual algorithms for binary operations for addition, subtraction and multiplication from grade school. Later in this document, a refresher for addition occurs. I also suggest that you design methods 

for the class BigPositiveInt in the following order: 

           constructors, toString(), add, multiply and subtract.

Answer 1

import java.util.ArrayList;

import java.io.*;

class BigInteger

{

protected String numstr;

int size;

public BigInteger(String numStr)

{

numstr = new String(numStr);

size = numstr.length();

}

public BigInteger() { numstr=null; size=0; }

public int GetSize() { return(numstr.length()); }

public String Get() { return (new String(numstr)); }

public BigInteger(BigInteger x)

{

numstr = new String(x.numstr);

size = numstr.length();

}

public BigInteger(int size, int digit)

{

String strnum = new String();

for (int iLoop=0; iLoop<size; iLoop++)

{

strnum = strnum + (new Integer(digit)).toString() ;

}

strnum.trim();

this.numstr = new String(strnum);

this.size = this.numstr.length();

}

public int LeadingZeros(int n)

{

int iReturn=0;

if (n > this.size)

{

int N = n - this.size;

BigInteger leadingZeros = new BigInteger(N,0);

this.numstr = new String( leadingZeros.Get() + this.numstr );

this.size = this.numstr.length();

}

else

{

iReturn = -1;

}

return(iReturn);

}

//adds to this and returns the sum

public BigInteger Add( BigInteger x)

{

BigInteger sum = null;

if (this.numstr!=null && x.numstr!=null)

{

//first, copies....

BigInteger A = new BigInteger(this);

BigInteger B = new BigInteger(x);

//Next, makes them the same size by padding with leading zeros...

int sizeA = A.GetSize();

int sizeB = B.GetSize();

int N;

if (sizeB > sizeA)

{

N = sizeB;

A.LeadingZeros(N);

}

else

{

N = sizeA;

B.LeadingZeros(N);

}

//Finally the addition

String numstrA = A.Get();

String numstrB = B.Get();

String sumStr=new String();

System.out.println(" numStrA = >" + numstrA + "< : numstrB = >" + numstrB + "<");

int iSum,carry=0;

int digitA,digitB;

for (int iLoop=N-1; iLoop>=0; iLoop--)

{

digitA = (int) (numstrA.charAt(iLoop)-48);

digitB = (int) (numstrB.charAt(iLoop)-48);

iSum = digitA + digitB + carry;

if (iSum>=10)

{

carry=1;

iSum %=10;

}

else

{

carry=0;

}

char chArray[] = new char[1];

chArray[0]= (char)(iSum+48);

sumStr = (new String( chArray)) + sumStr;

}

if (carry==1) { sumStr = "1" + sumStr; }

sum = new BigInteger(sumStr);

} //numstr not null

return(sum);

} //Add

//adds to this and returns the sum

public BigInteger Subtract( BigInteger x)

{

BigInteger difference = null;

if (this.numstr!=null && x.numstr!=null)

{

//first, copies....

BigInteger A = new BigInteger(this);

BigInteger B = new BigInteger(x);

//Next, makes them the same size by padding with leading zeros...

int sizeA = A.GetSize();

int sizeB = B.GetSize();

int N;

if (sizeB > sizeA)

{

N = sizeB;

A.LeadingZeros(N);

}

else

{

N = sizeA;

B.LeadingZeros(N);

}

//Finally the subtraction

String numstrA = A.Get();

String numstrB = B.Get();

String diffStr=new String();

System.out.println(" numStrA = >" + numstrA + "< : numstrB = >" + numstrB + "<");

int iDiff,borrow=0;

int digitA,digitB;

for (int iLoop=N-1; iLoop>=0; iLoop--)

{

digitA = (int) (numstrA.charAt(iLoop)-48);

digitB = (int) (numstrB.charAt(iLoop)-48);

if (borrow==1) { digitA--; }

if (digitA < digitB)

{

borrow=1;

iDiff = 10+digitA - digitB;

}

else

{

iDiff = digitA-digitB;

borrow=0;

}

char chArray[] = new char[1];

chArray[0]= (char)(iDiff+48);

diffStr = (new String( chArray)) + diffStr;

}

difference = new BigInteger(diffStr);

} //numstr not null

return(difference);

} //Add

public BigInteger MultiplyBy10()

{

return(

new BigInteger(

new String( this.numstr +"0")

)

);

}

public BigInteger MultiplyByDigit( int digit)

{

int carry=0;

int curProduct;

int curDigit;

int resultDigit;

BigInteger product=null;

String productStr = new String();

for (int iLoop=size-1; iLoop>=0; iLoop--)

{

curDigit = numstr.charAt(iLoop)-48;

curProduct = curDigit * digit + carry;

carry = curProduct/10;

resultDigit = curProduct%10 + 48;

char charArray[] = new char[1];

charArray[0] = (char)resultDigit;

productStr = new String(charArray) + productStr;

}

productStr = carry + productStr;

product = new BigInteger(productStr);

return(product);

}

public BigInteger Multiply(BigInteger x)

{

int n=x.GetSize();

BigInteger partialProducts[] = new BigInteger[n];

int powerOf10=0;

int curDigit;

String numStrX = x.Get();

int iIndexPos=0;

for (int iLoop= n-1; iLoop>=0; iLoop--)

{

curDigit = (int) (numStrX.charAt(iLoop)-48);

partialProducts[iIndexPos] = this.MultiplyByDigit(curDigit);

for (int exponentLoop=0; exponentLoop<powerOf10; exponentLoop++)

{

partialProducts[iIndexPos] = partialProducts[iIndexPos].MultiplyBy10();

}

System.out.println(" partial product # " + (iIndexPos+1) + ">" + partialProducts[iIndexPos].Get() + "<");

iIndexPos++;

powerOf10++;

}

int N = this.size * x.GetSize() + 1;

BigInteger product = new BigInteger(N,0);

for (int iLoop=0; iLoop<partialProducts.length; iLoop++)

{

product = product.Add(partialProducts[iLoop]);

}

return(product);

}

public static void main(String args[])

{

BigInteger x = new BigInteger("123456");

BigInteger y = new BigInteger("99999");

BigInteger sum = x.Add(y);

System.out.println(sum.Get());

BigInteger diff = x.Subtract(y);

System.out.println(diff.Get());

BigInteger xTimes10 = x.MultiplyBy10();

System.out.println(xTimes10.Get());

BigInteger yTimes5 = y.MultiplyByDigit(5);

System.out.println(yTimes5.Get());

BigInteger num1 = new BigInteger("321");

BigInteger num2 = new BigInteger("456");

BigInteger product = num1.Multiply(num2);

System.out.println(product.Get());

}

}