Question

(Huge Integer Class) Create a class HugeInteger which uses a 40 -element array of digits to store integers as large as 40 digits each. Provide methods parse, toString, add and subtract. Method parse should receive a String, extract each digit using method charAt and place the integer equivalent of each digit into the integer array. For comparing HugeInteger objects, provide the following methods: isEqualTo, isNotEqualTo, isGreaterThan, isLessThan, isGreaterThanOrEqualTo and isLessThanorEqualTo. Each of these is a predicate method that returns true if the relationship holds between the two HugeInteger objects and returns false if the relationship does not hold. Provide a predicate method iszero. If you feel ambitious, also provide methods multiply, divide and remainder. [Note: Primitive boolean values can be output as the word "true" or the word "false" with format specifier \(\% \text { b. }]\)

Short answer

Create the HugeInteger class with an array to store digits. Implement methods for parsing strings, adding/subtracting integers, and comparing. Optional methods include multiplication, division, and finding the remainder.

Step-by-step solution

Define the HugeInteger Class

Begin by defining the HugeInteger class with a 40-element integer array to store each digit of the integer. Inside the class, provide the necessary instance variables and methods as described.

Implement the parse Method

The parse method should take a String argument and convert its individual characters into digits, then store these digits in the array. Loop through each character of the input string (starting from the end), use `Character.getNumericValue()` to convert to an integer, and store it into the array.

Implement the toString Method

In the toString method, iterate through the array to form a String representation of the HugeInteger. Concatenate only the non-zero elements, taking care of leading zeros.

Implement the add Method

The add method should take another HugeInteger object and add it to the current instance. Implement the addition algorithm by adding corresponding digits and carrying over any overflow to the next digit.

Implement the subtract Method

The subtract method subtracts another HugeInteger object from the current instance. Implement the subtraction algorithm by subtracting corresponding digits and borrowing from the previous digit if necessary.

Implement Comparison Methods

Each comparison method (isEqualTo, isNotEqualTo, etc.) should compare the two HugeInteger instances based on the requested relation and return a boolean value.

Implement the isZero Method

The isZero method checks if a HugeInteger object represents the value zero. The method should return true if all elements of the integer array are zero.

Implement Additional Methods (Optional)

If desired, implement additional methods to perform multiplication, division, and finding the remainder. These are advanced operations and would require additional algorithms akin to long multiplication and division.

Key concepts

Object-oriented programming

Object-oriented programming (OOP) is a programming paradigm based on the concept of 'objects', which can contain data, in the form of fields, and code, in the form of procedures (also known as methods). A huge advantage of OOP is the ability to modularize code and create reusable components, which enhances maintainability and scalability.

In our HugeInteger class example, the class itself is the blueprint for creating objects that represent large integers. The data for these objects are stored in private member arrays, and the behavior is defined through methods like parse, add, subtract, and comparison operations. Encapsulation is another key concept at play here, keeping the data (the digits array) private and only accessible through public methods. This design approach keeps the data secure and allows changes to the underlying implementation without affecting the rest of the application that uses the class.

Java arrays

In Java, an array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created and cannot be changed after its creation. This makes arrays very efficient in terms of memory and performance for certain tasks, like storing a predefined number of elements.

The HugeInteger class uses a 40-element integer array as its core data structure for storing the individual digits of a large number. In the parse method, for example, the array is populated with the digit values extracted from a string. Arrays provide convenient access to their elements via index, which starts from zero, making them practical for the implementation of algorithms like addition and subtraction as demonstrated in the add and subtract methods of the class.

String manipulation

String manipulation is a common task in many programming languages, Java included. Strings in Java are objects that represent sequences of characters. They are immutable, which means once created, the value of a String cannot be changed.

In the context of the HugeInteger class, string manipulation is used within the parse method. We extract numeric digits from a string using the `charAt` method, which allows us to loop through each character of the String. After converting these characters to their integer equivalents, they are stored in the digits array. Similarly, the `toString` method is involved in string manipulation by iterating over the digits array and concatenating digits to form the full string representation of the HugeInteger.

Java arithmetic operations

Java provides a rich set of arithmetic operators to perform calculations on numbers, including addition (+), subtraction (-), multiplication (*), division (/), and modulus (%), which yields the remainder of division. In our HugeInteger class, we primarily use addition and subtraction.

These operations are not as straightforward when dealing with numbers that span 40 digits, far beyond the native size limitations of Java's integer types. Hence, we implement them manually. The add method performs digit-wise addition from right to left, carrying over any 'overflow' to the next digit. Conversely, the subtract method needs to handle borrowing from the higher digit when subtracting a larger digit from a smaller one. This meticulous attention to the behavior of each digit during arithmetic operations is essential for accurately modelling the behavior of large integers.