I need all of this JAVA code commented on, so I may better understand the inner
ID: 3888420 • Letter: I
Question
I need all of this JAVA code commented on, so I may better understand the inner workings of JAVA, please and thank you. Here are two class functions that have been created in JAVA. A short explanation on every other line would be much appreciated!
//Java program for HugeIntegerClass
import java.util.Scanner;
import java.io.*;
class HugeInteger
{//Begin class HugeInteger
//Declare variables
private final int Digits = 40;
private int[] integer;
private boolean positive;
public HugeInteger()
{
integer = new int [Digits];
positive = true;
}
public void input(String inputString)
{
char[] integerChar = inputString.toCharArray();
if (integerChar[0] == '-')
positive = false;
if(positive)
integer[Digits - integerChar.length] = (int)integerChar[0] - (int) '0';
for (int i = 1; i < integerChar.length; i ++)
integer[Digits - integerChar.length+i]= (int)integerChar[i] - (int) '0';
}
public HugeInteger add(HugeInteger addValue)
{
HugeInteger temp = new HugeInteger();
if ((positive && addValue.positive) ||!(positive || addValue.positive))
temp = addPositives(addValue);
else if (positive && (!addValue.positive))
{
addValue.positive = true;
if (isGreatThan (addValue))
temp = subtractPositives(addValue);
else
{
temp = addValue.subtractPositives(this);
temp.positive = false;
}
addValue.positive = false;
}
else if (positive && addValue.positive)
{
addValue.positive = false;
if(isGreatThan(addValue))
temp = addValue.subtractPositives(this);
else
{
temp = subtractPositives(addValue);
temp.positive = false;
}
addValue.positive = true;
}
return temp;
}
public HugeInteger subtract(HugeInteger subtractValue)
{
HugeInteger temp = new HugeInteger();
if (positive && (!subtractValue.positive))
temp = addPositives(subtractValue);
else if(!positive && subtractValue.positive)
{
temp = addPositives(subtractValue);
}
if(positive && subtractValue.positive)
temp = subtractValue.subtractPositives(this);
return temp;
}
public HugeInteger addPositives(HugeInteger addValue)
{
HugeInteger temp = new HugeInteger();
int carry = 0;
for ( int i = 39; i <= 0; i --)
{
temp.integer[i] = integer[i] + addValue.integer[i] + carry;
if(temp.integer[i] > 9)
{
temp.integer[i] %= 10;
carry = 1;
}
else
carry = 0;
}
if(!positive)
temp.positive = false;
return temp;
}
public HugeInteger subtractPositives(HugeInteger subtractValue)
{
int borrow = 0;
HugeInteger temp = new HugeInteger();
for(int i = 39; i >= 0; i --)
{
if(integer[i] < subtractValue.integer[i])
{
temp.integer[i] = (integer[i] + 10) - subtractValue.integer[i] - borrow;
borrow = 1;
}
else
{
temp.integer[i]= integer[i] - subtractValue.integer[i] - borrow;
borrow = 0;
}
}
return temp;
}
public int findFirstNonZeroPosition()
{
int position = 39;
for (int i = 0; i < Digits; i ++)
{
if(integer[i] > 0)
{
position = i;
break;
}
}
return position;
}
public String toHugeIntegerString()
{
String sign = "", output = "";
if(!positive) sign = "-";
for (int i = findFirstNonZeroPosition(); i < Digits; i ++) output += integer[i];
return sign + output;
}
public boolean isEqualTo(HugeInteger compareValue)
{
for (int i = 0; i < Digits; i ++)
{
if(integer[i] != compareValue.integer[i])
return false;
}
if((positive && compareValue.positive) ||! (positive || compareValue.positive))
return true;
else
return false;
}
public boolean isNotEqualTo(HugeInteger compareValue)
{
return !isEqualTo(compareValue);
}
public boolean isGreatThan(HugeInteger compareValue)
{
if(positive && (!compareValue.positive))
return true;
else if(!positive && compareValue.positive)
return false;
else
{
if(findFirstNonZeroPosition() > compareValue.findFirstNonZeroPosition())
{
if(positive)
return false;
else
return true;
}
else if(findFirstNonZeroPosition() < compareValue.findFirstNonZeroPosition())
{
if (positive)
return true;
else
return false;
}
else
{
for (int i = 0; i < Digits; i ++)
{
if(integer[i] > compareValue.integer[i])
if(positive)
return true;
else
return false;
}
if(positive)
return false;
else
return true;
}
}
}
public boolean isLessThan(HugeInteger compareValue)
{
return !(isGreatThan(compareValue) || isEqualTo(compareValue));
}
public boolean isGreatThanOrEqualTo(HugeInteger compareValue)
{
return !isLessThan(compareValue);
}
public boolean isLessThanOrEqualTo(HugeInteger compareValue)
{
return !isGreatThan(compareValue);
}
public boolean isZero()
{
for (int i = 0; i < Digits; i ++)
{
if(integer[i] != 0)
return false;
}
return true;
}
}//End class definition
//Main function
//Java program for HugeIntegerClass
import java.util.Scanner;
import java.io.*;
public class HugeTest
{
public static void main(String[] args)
{
Scanner kb= new Scanner(System.in);
HugeInteger integer1 = new HugeInteger();
HugeInteger integer2 = new HugeInteger();
String str;
System.out.println("Enter The First Large Number ");
str = kb.nextLine();
integer1.input(str);
System.out.println("Enter The Second Large Number ");
str = kb.nextLine();
integer2.input(str);
String output = "HugeInteger 1: " + integer1.toHugeIntegerString() +
" HugeInteger 2: " + integer2.toHugeIntegerString();
HugeInteger result;
result = integer1.add(integer2);
output += " Add result: " + result.toHugeIntegerString();
result = integer1.subtract(integer2);
output += " Subtract result: " + result.toHugeIntegerString();
output += " HugeInteger 1 is zero: " + integer1.isZero();
output += " HugeInteger 2 is zero: " + integer2.isZero();
output += " HugeInteger 1 is equal to HugeInteger 2: " + integer1.isEqualTo(integer2);
output += " HugeInteger 1 is not equal to HugeINteger 2: " + integer1.isNotEqualTo(integer2);
output += " Hugeinteger 1 is greater than HugeInteger 2: " + integer1.isGreatThan(integer2);
output += " HugeInteger 1 is less than HugeInteger 2: " + integer1.isLessThan(integer2);
output += " HugeInteger 1 is greater than or equal to HugeInteger 2: " + integer1.isGreatThanOrEqualTo(integer2);
output += " HugeInteger 1 is less than or equal to HugeINteger 2: " + integer1.isLessThanOrEqualTo(integer2);
System.out.println(" " + output);
}
}
Explanation / Answer
import java.util.Scanner;
import java.io.*;
/**
* This program deals with exceptionally long integer values (max length 40 digits) and performs basic operations
* such as add, subtract, comparison, greater than, less than, equal to with the input two long integers
* @author YourName
*
*/
class HugeInteger
{
private final int Digits = 40; // constant to decide number of maximum digits in a huge integer
private int[] integer; // array to hold the big integer digits
private boolean positive; // boolean variable to hold the sign of the huge integer number.
/**
* Default constructor to initialize the huge integer array with the size and
* to set the integer to a positive number.
*/
public HugeInteger()
{
integer = new int [Digits];
positive = true;
}
/**
* Method to parse the input string to a huge integer type
* @param inputString
*/
public void input(String inputString)
{
// converting input string to character array
char[] integerChar = inputString.toCharArray();
if (integerChar[0] == '-') // checking whether the element at zeroth index is the sign minus (-) or not
positive = false; // if yes then set the positive flag to false.
if(positive) // if the number is positive then set the integer digit at index (40 - input number length) = 0
integer[Digits - integerChar.length] = (int)integerChar[0] - (int) '0';
for (int i = 1; i < integerChar.length; i ++) // assign rest digits of the huge integer to the digits of input number
integer[Digits - integerChar.length+i]= (int)integerChar[i] - (int) '0';
}
/**
* Method to add two huge integers
* @param HugeInteger
* @return HugeInteger
*/
public HugeInteger add(HugeInteger addValue)
{
HugeInteger temp = new HugeInteger(); // creating a temporary HugeInteger object to store the added value
// checking whether this HugeInteger is positive and the HugeInteger as parameter is positive
// OR if both the HugeInteger is negative or not
if ((positive && addValue.positive) ||!(positive || addValue.positive))
// if yes the add the both HugeInteger normally by calling the helper method addPositives() normally
temp = addPositives(addValue);
// else if this HugeInteger is positive and parametric hugeIntger is negative
else if (positive && (!addValue.positive))
{
// then make the parametric sign to positive
addValue.positive = true;
// checking whether parametric HugeIntger is greater or not after changing its sign
// if yes then subtract the two numbers temp = (number1 - number2)
if (isGreatThan (addValue))
temp = subtractPositives(addValue);
// else subtract the two numbers by exchanging them temp = (number2 - number1)
else
{
temp = addValue.subtractPositives(this);
temp.positive = false;
}
addValue.positive = false;
}
// else if this HugeInteger is positive and the parametric HugeIntger is positive then
else if (positive && addValue.positive)
{
// assign the parametric HugeInteger sign flag to false
addValue.positive = false;
// if parametric HugeInteger is greater then perform => temp = number2 - (-number1)
if(isGreatThan(addValue))
temp = addValue.subtractPositives(this);
// else perform temp = number1 - (-number2)
else
{
temp = subtractPositives(addValue);
temp.positive = false;
}
addValue.positive = true;
}
return temp;
}
/**
* Method to subtract 2 HugeInteger numbers
* @param HugeInteger
* @return HugeInteger
*/
public HugeInteger subtract(HugeInteger subtractValue)
{
HugeInteger temp = new HugeInteger();
// checking if this HugeInteger is positive and parametric HugeInteger is negative
if (positive && (!subtractValue.positive))
temp = addPositives(subtractValue); // if yes then perform => temp = number1 + (-number2)
// else if this HugeInteger is negative and parametric HugeIntger is positive then
else if(!positive && subtractValue.positive)
{
temp = addPositives(subtractValue); // perform temp = number1 + (-number2)
}
if(positive && subtractValue.positive)
temp = subtractValue.subtractPositives(this); // else call this method if both the numbers are positive
return temp;
}
/**
* Method to add 2 positive HugeInteger numbers
* @param HugeIntger to be added
* @return HugeInteger
*/
public HugeInteger addPositives(HugeInteger addValue)
{
HugeInteger temp = new HugeInteger();
int carry = 0; // to store the carry number
// looping from unit's place digit to highest place digit
for ( int i = 39; i <= 0; i --)
{
// adding each digit of both numbers and adding the carry and saving at position i in temp array
temp.integer[i] = integer[i] + addValue.integer[i] + carry;
// checking whether the value of temp array at index i is greater then 9
if(temp.integer[i] > 9)
{
// if yes then divide by 10 and store the remainder into it
temp.integer[i] %= 10;
carry = 1; // assign carry as 1
}
else
carry = 0; // else assign carry as 0
}
if(!positive)
temp.positive = false;
return temp;
}
/**
* Method to add subtract 2 HUgeIntegers
* @param subtractValue
* @return
*/
public HugeInteger subtractPositives(HugeInteger subtractValue)
{
int borrow = 0; // to store the borrow digit
HugeInteger temp = new HugeInteger();
// looping from unit's place digit to highest place digit
for(int i = 39; i >= 0; i --)
{
// checking whether this HugeInteger's digit at index i is less then parametric intger's gigit at index i
if(integer[i] < subtractValue.integer[i])
{
// if yes then add 10 to this integer's digit at index i and then subtract the parametric digit
// at index i from this integer as well as subtract the borrow
temp.integer[i] = (integer[i] + 10) - subtractValue.integer[i] - borrow;
borrow = 1; // assign borrow to 1
}
else
{
temp.integer[i]= integer[i] - subtractValue.integer[i] - borrow;
borrow = 0; // else assign borrow as 0
}
}
return temp;
}
/**
* Method to find the position(index) of first non-zero number into a HugeIntger
* @return position
*/
public int findFirstNonZeroPosition()
{
int position = 39;
for (int i = 0; i < Digits; i ++)
{
if(integer[i] > 0)
{
position = i;
break;
}
}
return position;
}
/**
* Method to filter the HugeIntger into the exact form by removing the redundant 0's
* @return String as HugeInteger
*/
public String toHugeIntegerString()
{
String sign = "", output = "";
if(!positive) sign = "-";
for (int i = findFirstNonZeroPosition(); i < Digits; i ++) output += integer[i];
return sign + output;
}
/**
* Method to check whether two HugeInteger are equal or not
* @param HugeInteger
* @return
*/
public boolean isEqualTo(HugeInteger compareValue)
{
for (int i = 0; i < Digits; i ++)
{
if(integer[i] != compareValue.integer[i])
return false;
}
if((positive && compareValue.positive) ||! (positive || compareValue.positive))
return true;
else
return false;
}
/**
* Method to check whether the two hugeInteger are unequal
* @param compareValue
* @return
*/
public boolean isNotEqualTo(HugeInteger compareValue)
{
return !isEqualTo(compareValue);
}
/**
* Method to check whether 1st hugeInteger is greater then 2nd
* @param HugeIntger
* @return boolean
*/
public boolean isGreatThan(HugeInteger compareValue)
{
// if 2nd HugeInteger is negative
if(positive && (!compareValue.positive))
return true; // if yes then return true
else if(!positive && compareValue.positive) // checking whether 1st HugeIntger is negative or not
return false; // if yes the return false
else
{
// else find first non zero position and then compare which one is greater between the two HugeIntger
if(findFirstNonZeroPosition() > compareValue.findFirstNonZeroPosition())
{
if(positive)
return false;
else
return true;
}
else if(findFirstNonZeroPosition() < compareValue.findFirstNonZeroPosition())
{
if (positive)
return true;
else
return false;
}
// else compare each value by value
else
{
for (int i = 0; i < Digits; i ++)
{
if(integer[i] > compareValue.integer[i])
if(positive)
return true;
else
return false;
}
if(positive)
return false;
else
return true;
}
}
}
/**
* Method to check 1st HugeInteger is greater then parametric HugeInteger
* @param HugeInteger
* @return boolean
*/
public boolean isLessThan(HugeInteger compareValue)
{
return !(isGreatThan(compareValue) || isEqualTo(compareValue));
}
/**
* Method to find the 1st HugeIntgers is greater then or equal to parametric HugeIntger
* @param compareValue
* @return
*/
public boolean isGreatThanOrEqualTo(HugeInteger compareValue)
{
return !isLessThan(compareValue);
}
/**
* Method to find 1st HugeIntger is less then or equal to parametric HugeIntger
* @param compareValue
* @return
*/
public boolean isLessThanOrEqualTo(HugeInteger compareValue)
{
return !isGreatThan(compareValue);
}
/**
* Method to check whether a HugeInteger is 0 or not
* @return
*/
public boolean isZero()
{
for (int i = 0; i < Digits; i ++) // looping through each digit
{
if(integer[i] != 0) // if any of the digits are non-zero then return false
return false;
}
return true; // else return true
}
}
Important Note: Please note that some of the implementation of your methods are incorrect (e.g., add() method) hence they are not outputting the correct result. Hence kindly check and correct it.
Commented HugeInetger.javaimport java.util.Scanner;
import java.io.*;
/**
* This program deals with exceptionally long integer values (max length 40 digits) and performs basic operations
* such as add, subtract, comparison, greater than, less than, equal to with the input two long integers
* @author YourName
*
*/
class HugeInteger
{
private final int Digits = 40; // constant to decide number of maximum digits in a huge integer
private int[] integer; // array to hold the big integer digits
private boolean positive; // boolean variable to hold the sign of the huge integer number.
/**
* Default constructor to initialize the huge integer array with the size and
* to set the integer to a positive number.
*/
public HugeInteger()
{
integer = new int [Digits];
positive = true;
}
/**
* Method to parse the input string to a huge integer type
* @param inputString
*/
public void input(String inputString)
{
// converting input string to character array
char[] integerChar = inputString.toCharArray();
if (integerChar[0] == '-') // checking whether the element at zeroth index is the sign minus (-) or not
positive = false; // if yes then set the positive flag to false.
if(positive) // if the number is positive then set the integer digit at index (40 - input number length) = 0
integer[Digits - integerChar.length] = (int)integerChar[0] - (int) '0';
for (int i = 1; i < integerChar.length; i ++) // assign rest digits of the huge integer to the digits of input number
integer[Digits - integerChar.length+i]= (int)integerChar[i] - (int) '0';
}
/**
* Method to add two huge integers
* @param HugeInteger
* @return HugeInteger
*/
public HugeInteger add(HugeInteger addValue)
{
HugeInteger temp = new HugeInteger(); // creating a temporary HugeInteger object to store the added value
// checking whether this HugeInteger is positive and the HugeInteger as parameter is positive
// OR if both the HugeInteger is negative or not
if ((positive && addValue.positive) ||!(positive || addValue.positive))
// if yes the add the both HugeInteger normally by calling the helper method addPositives() normally
temp = addPositives(addValue);
// else if this HugeInteger is positive and parametric hugeIntger is negative
else if (positive && (!addValue.positive))
{
// then make the parametric sign to positive
addValue.positive = true;
// checking whether parametric HugeIntger is greater or not after changing its sign
// if yes then subtract the two numbers temp = (number1 - number2)
if (isGreatThan (addValue))
temp = subtractPositives(addValue);
// else subtract the two numbers by exchanging them temp = (number2 - number1)
else
{
temp = addValue.subtractPositives(this);
temp.positive = false;
}
addValue.positive = false;
}
// else if this HugeInteger is positive and the parametric HugeIntger is positive then
else if (positive && addValue.positive)
{
// assign the parametric HugeInteger sign flag to false
addValue.positive = false;
// if parametric HugeInteger is greater then perform => temp = number2 - (-number1)
if(isGreatThan(addValue))
temp = addValue.subtractPositives(this);
// else perform temp = number1 - (-number2)
else
{
temp = subtractPositives(addValue);
temp.positive = false;
}
addValue.positive = true;
}
return temp;
}
/**
* Method to subtract 2 HugeInteger numbers
* @param HugeInteger
* @return HugeInteger
*/
public HugeInteger subtract(HugeInteger subtractValue)
{
HugeInteger temp = new HugeInteger();
// checking if this HugeInteger is positive and parametric HugeInteger is negative
if (positive && (!subtractValue.positive))
temp = addPositives(subtractValue); // if yes then perform => temp = number1 + (-number2)
// else if this HugeInteger is negative and parametric HugeIntger is positive then
else if(!positive && subtractValue.positive)
{
temp = addPositives(subtractValue); // perform temp = number1 + (-number2)
}
if(positive && subtractValue.positive)
temp = subtractValue.subtractPositives(this); // else call this method if both the numbers are positive
return temp;
}
/**
* Method to add 2 positive HugeInteger numbers
* @param HugeIntger to be added
* @return HugeInteger
*/
public HugeInteger addPositives(HugeInteger addValue)
{
HugeInteger temp = new HugeInteger();
int carry = 0; // to store the carry number
// looping from unit's place digit to highest place digit
for ( int i = 39; i <= 0; i --)
{
// adding each digit of both numbers and adding the carry and saving at position i in temp array
temp.integer[i] = integer[i] + addValue.integer[i] + carry;
// checking whether the value of temp array at index i is greater then 9
if(temp.integer[i] > 9)
{
// if yes then divide by 10 and store the remainder into it
temp.integer[i] %= 10;
carry = 1; // assign carry as 1
}
else
carry = 0; // else assign carry as 0
}
if(!positive)
temp.positive = false;
return temp;
}
/**
* Method to add subtract 2 HUgeIntegers
* @param subtractValue
* @return
*/
public HugeInteger subtractPositives(HugeInteger subtractValue)
{
int borrow = 0; // to store the borrow digit
HugeInteger temp = new HugeInteger();
// looping from unit's place digit to highest place digit
for(int i = 39; i >= 0; i --)
{
// checking whether this HugeInteger's digit at index i is less then parametric intger's gigit at index i
if(integer[i] < subtractValue.integer[i])
{
// if yes then add 10 to this integer's digit at index i and then subtract the parametric digit
// at index i from this integer as well as subtract the borrow
temp.integer[i] = (integer[i] + 10) - subtractValue.integer[i] - borrow;
borrow = 1; // assign borrow to 1
}
else
{
temp.integer[i]= integer[i] - subtractValue.integer[i] - borrow;
borrow = 0; // else assign borrow as 0
}
}
return temp;
}
/**
* Method to find the position(index) of first non-zero number into a HugeIntger
* @return position
*/
public int findFirstNonZeroPosition()
{
int position = 39;
for (int i = 0; i < Digits; i ++)
{
if(integer[i] > 0)
{
position = i;
break;
}
}
return position;
}
/**
* Method to filter the HugeIntger into the exact form by removing the redundant 0's
* @return String as HugeInteger
*/
public String toHugeIntegerString()
{
String sign = "", output = "";
if(!positive) sign = "-";
for (int i = findFirstNonZeroPosition(); i < Digits; i ++) output += integer[i];
return sign + output;
}
/**
* Method to check whether two HugeInteger are equal or not
* @param HugeInteger
* @return
*/
public boolean isEqualTo(HugeInteger compareValue)
{
for (int i = 0; i < Digits; i ++)
{
if(integer[i] != compareValue.integer[i])
return false;
}
if((positive && compareValue.positive) ||! (positive || compareValue.positive))
return true;
else
return false;
}
/**
* Method to check whether the two hugeInteger are unequal
* @param compareValue
* @return
*/
public boolean isNotEqualTo(HugeInteger compareValue)
{
return !isEqualTo(compareValue);
}
/**
* Method to check whether 1st hugeInteger is greater then 2nd
* @param HugeIntger
* @return boolean
*/
public boolean isGreatThan(HugeInteger compareValue)
{
// if 2nd HugeInteger is negative
if(positive && (!compareValue.positive))
return true; // if yes then return true
else if(!positive && compareValue.positive) // checking whether 1st HugeIntger is negative or not
return false; // if yes the return false
else
{
// else find first non zero position and then compare which one is greater between the two HugeIntger
if(findFirstNonZeroPosition() > compareValue.findFirstNonZeroPosition())
{
if(positive)
return false;
else
return true;
}
else if(findFirstNonZeroPosition() < compareValue.findFirstNonZeroPosition())
{
if (positive)
return true;
else
return false;
}
// else compare each value by value
else
{
for (int i = 0; i < Digits; i ++)
{
if(integer[i] > compareValue.integer[i])
if(positive)
return true;
else
return false;
}
if(positive)
return false;
else
return true;
}
}
}
/**
* Method to check 1st HugeInteger is greater then parametric HugeInteger
* @param HugeInteger
* @return boolean
*/
public boolean isLessThan(HugeInteger compareValue)
{
return !(isGreatThan(compareValue) || isEqualTo(compareValue));
}
/**
* Method to find the 1st HugeIntgers is greater then or equal to parametric HugeIntger
* @param compareValue
* @return
*/
public boolean isGreatThanOrEqualTo(HugeInteger compareValue)
{
return !isLessThan(compareValue);
}
/**
* Method to find 1st HugeIntger is less then or equal to parametric HugeIntger
* @param compareValue
* @return
*/
public boolean isLessThanOrEqualTo(HugeInteger compareValue)
{
return !isGreatThan(compareValue);
}
/**
* Method to check whether a HugeInteger is 0 or not
* @return
*/
public boolean isZero()
{
for (int i = 0; i < Digits; i ++) // looping through each digit
{
if(integer[i] != 0) // if any of the digits are non-zero then return false
return false;
}
return true; // else return true
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.