Question

• +array:int[]
  • This is provided to facilitate testing and grading. Use it as your internal array.
• +size:int
  • i.e. after items are added to the array, or deleted from it.
• One default constructor (receives nothing and initializes an array of size 0), and another constructor that receives an int[] and initializes the internal array with the input parameter.
  • both of the constructors exist and work fine.
  • In initializing the internal array with the input parameter, you should make a copy of the input array. i.e. a change to the input array in other locations of your program should not change your internal array.
• +setArray(int[]): void
  • method can correctly receive an array of a certain size and update the internal array.
  • In updating the internal array with the input parameter, you should make a copy of the input array. i.e. a change to the input array in other locations of your program should not change your internal array.
• +setArray(String): void
  • method can correctly receive a comma separated string and update the internal array.
  • To do this you can use the split method. This method receives a string, splits the string based on a certain delimiter, and returns the items. For example, for storing a String str1 = "1,2,3", you can call the split method in this way: "String[] items = str1.split(",");". The items array will contain these items then: {"1","2","3"}. Since your internal array is integer, you will need to pars every item to integer at the end.
• +getArray():int[]
  • method correctly creates a copy of the array and returns that copy. The original array should not be returned (why?). So, most probably, this method will involve creating a copy array, copying every element from the internal array to that copy array, and then returning that copy array.
• +addItem(int):void
  • method can correctly add its input parameter at the end of the array.
  • This is one of the major enhancements of our data structure! There is no size limitations! If the user calls this method an unlimited amount of times, this method should still work fine. This means that for every new element, you will most probably need to initialize a new array with the new size and copy every element of the old array to this new array.
• +addItem(int,int):void
  • method can correctly insert its first input parameter at the index indicated in its second input parameter, and then shift the rest of elements already in the array to right. For example, if this is the current status of our internal array: {1,2,3,4,5,6,7,8,9}, me method call such as addItem(100,2) will result in this array: {1,2,100,3,4,5,6,7,8,9}
• +removeItem():int
  • method can correctly remove and return the item at the end of the array. If the current state of our internal array is {1,2,3,4,5,6,7,8,9}, a method call such as removeItem() will return 9 and result in this array: {1,2,3,4,5,6,7,8}
• +removeItem(int):int
  • method can correctly remove and return the item at the index indicated by the input parameter, shifting the rest of the elements to left. If the current state of our internal array is {1,2,3,4,5,6,7,8,9}, a method call such as removeItem(2) will return 3 and result in this array: {1,2,4,5,6,7,8,9}
• +isEmpty(): boolean
  • will be awarded if the method correctly returns true if the size of the array is 0, and returns false otherwise.
• +printArray():void
  • Write a method that prints the array to the console. This is just to help you with developing and testing your work.

Note:

• For this assignment, you can only use Arrays, Strings, Booleans, and Integers. You cannot use any other data structures (i.e. ArrayLists).

import java.util.Scanner;

class EnhancedArray{
   public int[] array = null; // An array that is not initialized has a null value.
   public int size;
  
/* Define your methods here */

   private void updateSize(){
   if(array!=null) { // This checks if the array is already initialized or not.
       this.size = array.length;
   }else {
       this.size = 0;
   }
   }

}
public class Main {
public static void main(String[] args) {
Scanner scnr = new Scanner(System.in);

/* Test your code here. */
}
}

Answer 1

EnhancedArray.java

import java.util.Scanner;

public class EnhancedArray {
   public int[] array = null; // An array that is not initialized has a null value.
   public int size;

   /* Define your methods here */

   //default constructor
   public EnhancedArray() {
       // initialize an array of 0 size
       array = new int[0];
   }

   //parameterized constructor
   public EnhancedArray(int[] arr) {
       this.array = arr;
       updateSize();
   }

   // Method that updates the size of the array
   private void updateSize() {
       if(array != null) { // This checks if the array is already initialized or not.
           this.size = array.length;
       } else {
           this.size = 0;
       }
   }

   // Method that correctly receives an array of a certain size and update the internal array.
   public void setArray(int[] arr) {
       //copy the array and update the size of the array
       this.array = arr;
       updateSize();
   }

   // Method that correctly receives a comma separated string and update the internal array.
   public void setArray(String arr) {
       //split the string based on ","
       String[] items = arr.split(",");

       //initialize the array
       this.array = new int[items.length];
       updateSize();

       //store the items into the array
       for(int i = 0; i < items.length; i++) {
           array[i] = Integer.parseInt(items[i]);
       }
   }

   // Method that correctly creates a copy of the array and returns that copy.
   public int[] getArray() {
       //return the copy of the array
       int[] arr = this.array;
       return arr;
   }

   // Method that can correctly add its input parameter at the end of the array.
   public void addItem(int item) {
       //create an new array with size 1 greater than the original array
       int arr[] = new int[this.size + 1];
       //copy the array
       for(int i = 0; i < size; i++) {
           arr[i] = this.array[i];
       }
       //add the item at the end of the array
       arr[arr.length - 1] = item;
       //replace the array and update its size
       this.array = arr;
       updateSize();
   }

   // Method that correctly inserts its first input parameter at the index indicated in its second input parameter, and then shift the rest of elements already in the array to right
   public void addItem(int item, int index) {
       //display error message if index is out of bounds
       if(index > size-1)
           System.out.println("Index is out of bounds.");
       else
       {
           //create an new array with size 1 greater than the original array
           int arr[] = new int[this.size + 1];
           //copy the items before the index specified
           for(int i = 0; i < index; i++) {
               arr[i] = this.array[i];
           }
           //add the item at the specified index
           arr[index] = item;
           //move the rest of the items to the right
           for(int i = index; i < size; i++) {
               arr[i + 1] = array[i];
           }
           //replace the array and update the size
           this.array = arr;
           updateSize();
       }  
   }

   // Method that correctly removes and returns the item at the end of the array.
   public int removeItem() {
       //store the item that is removed
       int itemRemoved = this.array[size-1];
       //create a new array with size 1 less than the original array
       int[] arr = new int[size -1];
       //copy the items from the original array leaving the last item
       for(int i = 0; i < size-1; i++) {
           arr[i] = this. array[i];
       }
       //replace the array and update the size
       this.array = arr;
       updateSize();
       return itemRemoved;
   }

   // Method that correctly removes and returns the item at the index indicated by the input parameter, shifting the rest of the elements to left.
   public int removeItem(int index) {
       int itemRemoved = -1;
       //display error if index specified is out of bounds
       if(index > size-1)
           System.out.println("Index is out of bounds.");
       else
       {
           //store the item that is removed
           itemRemoved = this.array[index];
           //create a new array with size 1 less than the original array
           int[] arr = new int[size -1];
           //copy the elements before the index elements
           for(int i = 0; i < index; i++) {
               arr[i] = this. array[i];
           }
           //copy the rest of the items leaving the item to be removed
           for(int i = index + 1; i < size; i++) {
               arr[i - 1] = this. array[i];
           }

           //replace the array and update the size
           this.array = arr;
           updateSize();
       }
       return itemRemoved;
   }

   // Method that returns true if the array is empty
   public boolean isEmpty() {
       if(this.size == 0)
           return true;
       else
           return false;
   }

   // Method that prints the array to console
   public void printArray() {
       for(int i = 0; i < size; i++) {
           if(i == 0)
               System.out.print("{" + this.array[i]);
           else if(i == size -1)
               System.out.print(", " + this.array[i] + "}\n");
           else
               System.out.print(", " + this.array[i]);
       }
   }
}

Main.java

import java.util.Scanner;

public class Main {

   public static void main(String[] args) {
       Scanner scnr = new Scanner(System.in);
      
       /* Test your code here. */
      
       //create an object to the EnhacedArray class
       EnhancedArray myArray = new EnhancedArray();
       //set the elements in the array using a string
       myArray.setArray("1,2,3,4,5,6,7,8,9");
       //print the elements in the array
       System.out.println("The items in the array are: ");
       myArray.printArray();
  
       //get the items in the array
       int[] copy = myArray.getArray();
       //create an object to the EnhancedArray class using the array returned from getArray
       EnhancedArray copyOfArray = new EnhancedArray(copy);
       //display the array
       System.out.println("The items in the copy of the array are: ");
       copyOfArray.printArray();
      
       //Read the item to added to the array
       System.out.print("\nEnter an item to be added into the array: ");
       int item = scnr.nextInt();
       //add the item to the array
       myArray.addItem(item);
       //display the array
       System.out.println("\nThe items in the array after adding an item: ");
       myArray.printArray();
      
       //Read the item to added to the array
       System.out.print("\nEnter an item to be added into the array: ");
       item = scnr.nextInt();
       //read the index where the item has to be inserted
       System.out.print("Enter the index where the item is to be added: ");
       int index = scnr.nextInt();
       //add the item
       myArray.addItem(item, index);
       //display the array
       System.out.println("\nThe items in the array after adding an item: ");
       myArray.printArray();
      
       //remove an item from the array and display the array
       int itemRemoved = myArray.removeItem();
       System.out.println("\nRemoving an item from the array...");
       System.out.println("The item removed is: " + itemRemoved);
       System.out.println("\nThe items in the array after removing an item: ");
       myArray.printArray();
      
       //read the index of the item to be removed
       System.out.print("\nEnter the index of the item to be removed: ");
       index = scnr.nextInt();
      
       //remove the item and display the array
       itemRemoved = myArray.removeItem(index);
       System.out.println("The item removed is: " + itemRemoved);
       System.out.println("\nThe items in the array after adding an item: ");
       myArray.printArray();
      
       if(myArray.isEmpty())
           System.out.println("\nThe array is empty");
       else
           System.out.println("\nThe array is not empty");
      
       scnr.close();
   }

}

Output:

Program Screenshot:

Let me know if you have any concerns with the above solution.