Question

In Java, Implement a class MyArray as defined below, to store an array of integers (int). Many of its methods will be implemented using the principle of recursion.

Users can create an object by default, in which case, the array should contain enough space to store 10 integer values. Obviously, the user can specify the size of the array s/he requires. Users may choose the third way of creating an object of type MyArray by making a copy of another MyArray object given as parameter.

MyArray supports the following operations.

• getSize: returns the size of the array.

• get (i): returns the i-th element of the array. If the element does not exist, it throws a "NoSuchElementException” which is a subclass of Java class RunTimeException.

• add (val): inserts value as the last element of the array. If necessary, double the size of the current array to accommodate the new item.

• equals: Two MyArrays are equal if they have the same number of elements in the same order. Implement this overriding method recursively.

• sum: returns the sum of all elements of the array. Implement this recursively.

• max: returns the largest element of the array. Implement this recursively.

• min: returns the smallest element of the array. Implement this recursively.

• srch (elt): Searches for the element using the recursive binary search algorithm and returns the index of position where it is found, -1 if not found.

• sort: Sorts the array using the bubble sort algorithm. Implement this recursively.

• invert: Inverts the order of elements in the array. Implement this recursively.

• toString: This must return a String which contains complete information about the array including how many elements it has and what are their values. Overrides the same method in the Object class.

The private instance variables of MyArray are an array of integers, and how many elements does it have.

It is perfectly legal to use the services of private methods to implement any recursive algorithms you wish. That is, you can implement some of the above methods with a call to another (private) method of the class passing appropriate parameters.

To test your implementation of MyArray class, write a test program as follows:

• Create a default MyArray MA1.

• Prompt the user for the name of the input and output files.

• Output the size of MA1.

• Read the number of elements to insert in MA1. Let this be n. [This is the first line of input from the file.]

• Now, read n integer values from the file and insert them in MA1 in that order.

• Output the size of MA1.

• Output MA1.

• Find and output the largest and smallest elements of MA1.

• Output the sum of all elements of MA1.

• Create another MyArray MA2 by copying MA1.

• Check and output if MA1 and MA2 are equal.

• Sort MA2 using the recursive bubble sort algorithm.

• Check and output if MA1 and MA2 are equal.

• Output MA2.

• Read the search elements from the input file (just continue to read the input file) till the end of the file, and for eachelement, output if that element exists in MA2. If it does, output its position; otherwise indicate that it does not exist in the array.

• Invert MA2.

• output MA2

Using the following code to read from a text

import java.io.FileReader;
import java.io.PrintWriter;
import java.util.Scanner;
import javax.swing.JOptionPane;

public class fileIO {
public static void main (String[] args) throws Exception
{ String inf = JOptionPane.showInputDialog("Input file?");
// Input file is src/<name of the file>
FileReader inFile = new FileReader(inf);
Scanner in = new Scanner(inFile);
String outf = JOptionPane.showInputDialog("Output file?");
PrintWriter outFile = new PrintWriter(outf);
while (in.hasNextLine())
{ String line = in.nextLine();
outFile.println(line+"\n");
}
outFile.close();
}
}

Answer 1

MyArray.java

======================

import java.util.NoSuchElementException;

public class MyArray {

   // data fields
   private int array[]; // array to store data
   private int CAPACITY; // maximum capacity of array
   private int size; // total number of elements in array
  
   // default constructor
   public MyArray() {
       // create array of capacity 10
       this(10);
   }
  
   // constructor with parameter
   public MyArray(int capacity) {
       // initialize data
       this.CAPACITY = capacity;
       array = new int[CAPACITY];
       size = 0;
   }
  
   // copy constructor
   public MyArray(MyArray other) {
       // initialize this array and copy each element from given array
       this.CAPACITY = other.CAPACITY;
       this.size = other.size;
       this.array = new int[CAPACITY];
       for(int i=0; i<size; i++) {
           this.array[i] = other.array[i];
       }
   }
  
   // returns the size of the array
   public int getSize() {
       return size;
   }

   // returns the i-th element of the array
   // if the element does not exist, it throws a "NoSuchElementException”
   public int get(int i) {
       // check for valid index
       if(i < 0 || i >= size) {
           throw new NoSuchElementException();
       }
       return array[i];
   }
  
   // inserts value as the last element of the array
   // if necessary, double the size of the current array to accommodate the new item
   public void add(int val) {
       // validate size of array
       if(size == CAPACITY) {
           // double the array size
           CAPACITY = CAPACITY * 2;
           int[] temp = new int[CAPACITY];
           // copy each element
           for(int i=0; i<size; i++) {
               temp[i] = array[i];
           }
           array = temp;
       }
       // add element to end of array
       array[size] = val;
       size++;
   }

   // Two MyArrays are equal if they have the same number of elements in the same order
   public boolean equals(MyArray other) {
       // call private method recursively to check if both arrays are equal
       if(this.size != other.size) {
           return false;
       }
       else {
           return equals(other, size - 1);
       }
   }
  
   private boolean equals(MyArray other, int i) {
       // base case
       if(i < 0) {
           return true;
       }
       // recursive step
       if(this.array[i] == other.array[i]) {
           return equals(other, i - 1);
       }
       return false;
   }

   // returns the sum of all elements of the array
   public int sum() {
       // compute sum by recursively calling private sum method
       return sum(size - 1);
   }
  
   private int sum(int i) {
       // base case
       if(i < 0) {
           return 0;
       }
       // recursive step
       return sum(i - 1) + array[i];
   }

   // returns the largest element of the array
   public int max() {
       // recursively compute maximum element in array
       return max(array[size - 1], size - 1);
   }
  
   private int max(int max, int index) {
       // base case
       if(index < 0) {
           return max;
       }
       // recursive step
       else if(array[index] > max) {
           return max(array[index], index - 1);
       }
       else {
           return max(max, index - 1);
       }
   }

   // returns the smallest element of the array
   public int min() {
       // recursively compute maximum element in array
       return min(array[size - 1], size - 1);
   }
  
   private int min(int min, int index) {
       // base case
       if(index < 0) {
           return min;
       }
       // recursive step
       else if(array[index] < min) {
           return min(array[index], index - 1);
       }
       else {
           return min(min, index - 1);
       }
   }

   // Searches for the element using the recursive binary search algorithm
   // returns the index of position where it is found, -1 if not found.
   public int search(int element) {
       // recursively call search method to find element
       return search(element, size - 1);
   }

   private int search(int element, int index) {
       // base case
       if(index < 0) {
           return -1;
       }
       if(array[index] == element) {
           return index;
       }
       // recursive step
       return search(element, index - 1);
   }

   // Sorts the array using the bubble sort algorithm
   public void sort() {
       // recursively call sort method to sort the array
       sort(size - 1);
   }
  
   private void sort(int index) {
       // base case
       if(index < 0) {
           return;
       }
       // recursive step
       // find max and put it at index location
       int max = max(array[index], index);
       // find index of max
       int maxIndex = search(max);
       // swap max with last element in array
       int temp = array[index];
       array[index] = max;
       array[maxIndex] = temp;
       sort(index - 1);
   }

   // Inverts the order of elements in the array
   public void invert() {
       // invert array by recursively swapping positions
       invert(0, size - 1);
   }
  
   private void invert(int start, int end) {
       // base case
       if(start >= end) {
           return;
       }
       // recursive step
       int temp = array[start];
       array[start] = array[end];
       array[end] = temp;
       invert(start + 1, end - 1);
   }

   // returns a String which contains complete information about the array including how many elements it has
   // and what are their values. Overrides the same method in the Object class.
   @Override
   public String toString() {
       String str = "There are " + size + " elements in array.\n[";
       if(size > 0) {
           // add first element
           str = str + array[0];
       }
       // add remaining elements
       for(int i=1; i<size; i++) {
           str = str + ", " + array[i];
       }
       return str + "]";
   }
  
}

======================

fileIO.java

======================

import java.io.FileReader;
import java.io.PrintWriter;
import java.util.Scanner;
import javax.swing.JOptionPane;

public class fileIO {
  
   // main method to test MyArray
   public static void main (String[] args) throws Exception{
      
       // Create a default MyArray MA1
       MyArray MA1 = new MyArray();

       // Prompt the user for the name of the input and output files
       String inf = JOptionPane.showInputDialog("Input file?");
       // Input file is src/<name of the file>
       FileReader inFile = new FileReader(inf);
       Scanner in = new Scanner(inFile);
       String outf = JOptionPane.showInputDialog("Output file?");
       PrintWriter outFile = new PrintWriter(outf);

       // Output the size of MA1
       outFile.append(String.format("Size: %d\n", MA1.getSize()));
      
       // Read the number of elements to insert in MA1. Let this be n. [This is the first line of input from the file.]
       int size = Integer.parseInt(in.nextLine());
      
       // Now, read n integer values from the file and insert them in MA1 in that order
       for(int i=0; i<size; i++) {
           MA1.add(in.nextInt());
       }
      
       // Output the size of MA1
       // Output MA1.
       outFile.append(MA1.toString());
       outFile.append("\n");
      
       // Find and output the largest and smallest elements of MA1
       outFile.append(String.format("Min: %d\n", MA1.min()));
       outFile.append(String.format("Max: %d\n", MA1.max()));
      
       // Output the sum of all elements of MA1
       outFile.append(String.format("Sum: %d\n", MA1.sum()));
      
       // Create another MyArray MA2 by copying MA1
       MyArray MA2 = new MyArray(MA1);
      
       // Check and output if MA1 and MA2 are equal
       outFile.append(String.format("MA1 and MA2 are equal? %s\n", MA1.equals(MA2)));
      
       // Sort MA2 using the recursive bubble sort algorithm
       MA2.sort();
      
       // Check and output if MA1 and MA2 are equal
       outFile.append(String.format("MA1 and MA2 are equal? %s\n", MA1.equals(MA2)));
      
       // Output MA2
       outFile.append(MA2.toString());
       outFile.append("\n");
  
       // Read the search elements from the input file (just continue to read the input file) till the end of the file,
       // and for each element, output if that element exists in MA2
       // If it does, output its position; otherwise indicate that it does not exist in the array
       while(in.hasNext()) {
           int elem = in.nextInt();
           int pos = MA2.search(elem);
           if(pos == -1) {
               outFile.append("Element: " + Integer.toString(elem) + " does not exist in array\n");          
           }
           else {
               outFile.append("Element: " + Integer.toString(elem) + " found in array at position: " + Integer.toString(pos) + "\n");
           }
       }

       // Invert MA2.
       MA2.invert();
              
       // output MA2
       outFile.append(MA2.toString());
       outFile.append("\n");
  
       // close files
       outFile.close();
       in.close();
   }
}

====================

input.txt

====================

10
5
-4
75
94
0
1
3
45 68
77 0 54

let me know if you have problem or doubts. thank you.