Please give me the correct GroceryList.java

* LabProgram.java

import java.io.PrintWriter; import java.util.Scanner; import java.util.ArrayList; import java.util.Arrays;

public class LabProgram { public static void main(String[] args) { Scanner scnr = new Scanner(System.in); GroceryList groceryList = new GroceryList(); PrintWriter testFeedback = new PrintWriter(System.out);

String command; boolean quit = false;

while (!quit) { command = scnr.nextLine();

// Process user input if (command.equals("print")) { groceryList.print(testFeedback); } else if (0 == command.indexOf("add ")) { groceryList.addWithUndo(command.substring(4)); } else if (0 == command.indexOf("removeat ")) { int index = Integer.parseInt(command.substring(9)); groceryList.removeAtWithUndo(index); } else if (0 == command.indexOf("swap ")) { int index1 = -1, index2 = -1; String str = command.substring(5);

if (str.indexOf(" ") != -1) { index1 = Integer.parseInt(str.substring(0, 1)); index2 = Integer.parseInt(str.substring(2, 3)); groceryList.swapWithUndo(index1, index2); } else { System.out.print("\"swap\" command requires two indices, separated "); System.out.println("by a space. Ex: swap 2 5"); } } else if (command.equals("undo")) { if (0 == groceryList.getUndoStackSize()) { System.out.println("Cannot execute undo because undo stack is empty"); } else { groceryList.executeUndo(); } } else if (command.equals("quit")) { quit = true; } else { System.out.println("Unknown command: " + command); } testFeedback.flush(); } } }

* UndoCommand.java

public abstract class UndoCommand { public abstract void execute(); }

RemoveLastCommand.java

import java.util.ArrayList;

// Class to implement the undo operation for adding a new item to the grocery list public class RemoveLastCommand extends UndoCommand { private ArrayList sourceList;

public RemoveLastCommand(ArrayList lst) { this.sourceList = lst; }

@Override public void execute() { // Remove the last item from the source list sourceList.remove(sourceList.size() - 1); } }

*SwapCommand.java

import java.util.ArrayList;

// Class to implement the undo operation for swapping two items in the grocery list public class SwapCommand extends UndoCommand { private ArrayList sourceList; private int index1, index2; private String temp;

public SwapCommand(ArrayList lst, int i1, int i2) { this.sourceList = lst; this.index1 = i1; this.index2 = i2; }

@Override public void execute() { // Swap the two items by using a temporary variable temp = sourceList.get(index1); sourceList.set(index1, sourceList.get(index2)); sourceList.set(index2, temp); } }

* InsertAtCommand.java

import java.util.ArrayList;

// Class to implement the undo operation for removing an item from the grocery list public class InsertAtCommand extends UndoCommand { private ArrayList sourceList; private int index; private String item;

public InsertAtCommand(ArrayList lst, int i, String it) { this.sourceList = lst; this.index = i; this.item = it; }

@Override public void execute() { // Insert the removed item back into the source list at the specified index sourceList.add(index, item); } }

* GroceryList.java

import java.util.*; import java.io.PrintWriter;

public class GroceryList { // An ArrayList to store the list items protected ArrayList listItems = new ArrayList(); // A Stack to store the undo commands protected Stack undoStack = new Stack();

// Adds a new item to the list and stores the undo command public void addWithUndo(String newItemName) { // Add the new list item listItems.add(newItemName); // Make an undo command that removes the last item and push onto stack undoStack.push(new RemoveLastCommand(listItems)); }

// Removes the item at the given index and stores the undo command public void removeAtWithUndo(int removalIndex) { // Check if the index is within the bounds of the list if (removalIndex >= 0 && removalIndex

// Swaps the items at the given indices and stores the undo command public void swapWithUndo(int index1, int index2) { // Check if both indices are within the bounds of the list if (index1 >= 0 && index1 = 0 && index2

// Pop and execute the command at the top of the undo stack public void executeUndo() { if (undoStack.empty()) { System.out.println("Cannot execute undo because undo stack is empty."); } else { undoStack.pop().execute(); } }

// Returns the size of the list public int getListSize() { return listItems.size(); }

// Returns the size of the undo stack public int getUndoStackSize() { return undoStack.size(); }

// Returns a copy of the list public ArrayList getVectorCopy() { return new ArrayList(listItems); }

// Prints the list items to the given output stream public void print(PrintWriter outputStream) { for (int i = 0; i

Program errors displayed here

GroceryList.java:26: error: incompatible types: String cannot be converted to int undoStack.push(new InsertAtCommand(listItems, removedItem, removalIndex)) ; ^ Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output 1 error

In this lab a grocery list editor with undo functionality is implemented. Step 1: Inspect the UndoCommand abstract base class The read-only UndoCommand.java file has a declaration for the UndoCommand abstract base class. Access UndoCommand.java by clicking on the orange arrow next to LabProgram.java at the top of the coding window. The UndoCommand class represents a command object: an object that stores all needed information to execute an action at a later point in time. For this lab, a command object stores information to undo a grocery list change made by the user. Step 2: Inspect the incomplete GroceryList class The GroceryList class is declared in GroceryList.java. Two protected fields are declared: - An ArrayList of strings for list items - A stack of UndoCommand references for undo commands Note that the addWithUndo0 method is already implemented. The method adds a new item to the list and pushes a new RemoveLastCommand object onto the undo stack. Step 3: Implement RemoveLastCommand's execute() method The RemoveLastCommand class inherits from UndoCommand and is declared in RemoveLastCommand.java. When a RemoveLastCommand object is executed, the string ArrayList's last element is removed. So when the user appends a new item to the grocery list, a RemoveLastCommand is pushed onto the stack of undo commands. Popping and executing the RemoveLastCommand then removes the item most recently added by the user. RemoveLastCommand's sourceList field and constructor are already declared: - sourceList is a reference to a GroceryList object's ArrayList of strings. - The constructor takes a reference to an ArrayList of strings as a parameter, and assigns sourceList with the reference. Implement RemoveLastCommand's execute() method to remove sourceList's last element. Step 4: Implement GroceryList's executeUndo() method Implement GroceryList's executeUndo() method to do the following: - Pop an UndoCommand off the undo stack - Execute the popped undo command File LabProgram.java has code that reads in a list of commands, one per line, that allow for basic testing of basic operations. So after implementing executeUndo(), run your program with the following input: Verify that the corresponding output is: 0. bananas 1. grapes 2. strawberries 0 . bananas 1. grapes 0 . bananas The program's output does not affect grading, so additional test cases can be added, if desired. Submitting code written so far to obtain partial credit is recommended before proceeding to the next step