Question
Complete the three empty methods (remove(), find(), and contains()) in the ShoppingListArrayList.java file. These methods are already implemented in the ShoppingListArray class. Complete the ShoppingListArrayListTest.java
- Complete the three empty methods (remove(), find(), and contains()) in the ShoppingListArrayList.java file. These methods are already implemented in the ShoppingListArray class.
- Complete the ShoppingListArrayListTest.java (For many tests, we now just throw a false statement which will cause the test cases to fail. You need to complete them.)
ShoppingListArrayList
package Shopping;
import DataStructures.*; import java.io.FileNotFoundException; import java.util.ArrayList; import java.util.Scanner;
/** * @version Spring 2019 * @author Paul Franklin, Kyle Kiefer */ public class ShoppingListArrayList implements ShoppingListADT {
private ArrayList
/** * Default constructor of ShoppingArray object. */ public ShoppingListArrayList() { this.shoppingList = new ArrayList<>(); }
/** * Constructor of ShoppingArray object that parses from a file. * * @param filename the name of the file to parse * @throws FileNotFoundException if an error occurs when parsing the file */ public ShoppingListArrayList(String filename) throws FileNotFoundException { this.shoppingList = new ArrayList<>(); scanFile(filename); }
/** * Method to add a new entry. Only new entries can be added. Combines * quantities if entry already exists. * * @param entry the entry to be added */ @Override public void add(Grocery entry) {
// Check if this item already exists if (this.contains(entry)) { //Merge the quantity of new entry into existing entry combineQuantity(entry); return; }
shoppingList.add(entry); }
/** * Method to remove an entry. * * @param ent to be removed * @return true when entry was removed * @throws DataStructures.ElementNotFoundException */ @Override public boolean remove(Grocery ent) { // the boolean found describes whether or not we find the // entry to remove boolean found = false;
// search in the shoppingList, if find ent in the // list remove it, set the value of `found'
// Return false if not found return found; }
/** * Method to find an entry. * * @param index to find * @return the entry if found * @throws Exceptions.EmptyCollectionException */ @Override public Grocery find(int index) throws IndexOutOfBoundsException, EmptyCollectionException { if (this.isEmpty()) { throw new EmptyCollectionException("ECE - find"); } throw new IndexOutOfBoundsException("ArrayList - find"); // check whether or not the input index number is legal // for example, < 0 or falls outside of the size // return the corresponding entry in the shoppingList // need to change the return value // return null; }
/** * Method to locate the index of an entry. * * @param ent to find the index * @return the index of the entry * @throws ElementNotFoundException if no entry was found */ @Override public int indexOf(Grocery ent) throws ElementNotFoundException { for (int i = 0; i < shoppingList.size(); i++) { if (shoppingList.get(i).compareTo(ent) == 0) { return i; } }
throw new ElementNotFoundException("indexOf"); }
/** * Method to determine whether the object contains an entry. * * @param ent to find * @return true if and only if the entry is found */ @Override public boolean contains(Grocery ent) { boolean hasItem = false;
// go through the shoppingList and try to find the // item in the list. If found, return true.
return hasItem; }
/** * Gets the size of the collection. * * @return the size of the collection */ @Override public int size() { return shoppingList.size(); }
/** * Gets whether the collection is empty. * * @return true if and only if the collection is empty */ @Override public boolean isEmpty() { return shoppingList.isEmpty(); }
/** * Returns a string representing this object. * * @return a string representation of this object */ @Override public String toString() { StringBuilder s = new StringBuilder(); s.append(String.format("%-25s", "NAME")); s.append(String.format("%-18s", "CATEGORY")); s.append(String.format("%-10s", "AISLE")); s.append(String.format("%-10s", "QUANTITY")); s.append(String.format("%-10s", "PRICE")); s.append(' '); s.append("------------------------------------------------------------" + "-------------"); s.append(' '); for (int i = 0; i < shoppingList.size(); i++) { s.append(String.format("%-25s", shoppingList.get(i).getName())); s.append(String.format("%-18s", shoppingList.get(i).getCategory())); s.append(String.format("%-10s", shoppingList.get(i).getAisle())); s.append(String.format("%-10s", shoppingList.get(i).getQuantity())); s.append(String.format("%-10s", shoppingList.get(i).getPrice())); s.append(' '); s.append("--------------------------------------------------------" + "-----------------"); s.append(' '); }
return s.toString(); }
/** * Add the quantity of a duplicate entry into the existing * * @param entry duplicate */ private void combineQuantity(Grocery entry) { try { int index = this.indexOf(entry); shoppingList.get(index).setQuantity( shoppingList.get(index).getQuantity() + entry.getQuantity()); } catch (ElementNotFoundException e) { System.out.println("combineQuantity - ECE"); }
}
/** * Scans the specified file to add items to the collection. * * @param filename the name of the file to scan * @throws FileNotFoundException if the file is not found */ private void scanFile(String filename) throws FileNotFoundException { Scanner scanner = new Scanner(getClass().getResourceAsStream(filename)) .useDelimiter("(,| )");
while (scanner.hasNext()) { Grocery temp = new Grocery(scanner.next(), scanner.next(), Integer.parseInt(scanner.next()), Float.parseFloat(scanner.next()), Integer.parseInt(scanner.next())); add(temp); } }
}
ShoppingListArrayListTest
package Shopping;
import DataStructures.*; import org.junit.Test; import static org.junit.Assert.*; import org.junit.Before;
/** * @version Spring 2019 * @author Paul Franklin, Kyle Kiefer */ public class ShoppingListArrayListTest {
private ShoppingListArrayList instance;
/** * Initialize instance and entries */ @Before public void setupTestCases() { instance = new ShoppingListArrayList(); }
/** * Test of add method, of class ShoppingArray. */ @Test public void testAdd() { assertTrue(0==1); }
/** * Test of remove method, of class ShoppingArrayList. */ @Test public void testRemove() { assertTrue(0==1); }
/** * Test of find method, of class ShoppingArrayList. */ @Test public void testFind() { assertTrue(0==1); }
/** * Test of indexOf method, of class ShoppingArrayList. */ @Test public void testIndexOf() { assertTrue(0==1); }
/** * Test of contains method, of class ShoppingArrayList. */ @Test public void testContains() { assertTrue(0==1); }
/** * Test of size method, of class ShoppingArrayList. */ @Test public void testSize() { Grocery entry1 = new Grocery("Mayo", "Dressing / Mayo", 1, 2.99f, 1);
assertEquals(0, instance.size());
instance.add(entry1);
// Test increment assertEquals(1, instance.size());
assertTrue(instance.remove(entry1));
// Test decrement assertEquals(0, instance.size()); }
/** * Test of isEmpty method, of class ShoppingArrayList. */ @Test public void testIsEmpty() { Grocery entry1 = new Grocery("Mayo", "Dressing / Mayo", 1, 2.99f, 1);
// Test empty assertTrue(instance.isEmpty());
instance.add(entry1);
// Test not empty assertFalse(instance.isEmpty()); }
}
ShoppingListADT
public interface ShoppingListADT { /** * Method to add a new entry to the shopping list. If a matching item already * exists, the quantities are combined * * @param entry the new item to add */ public void add(Grocery entry);
/** * Method to remove a specific entry from the shopping list * * @param entry the item to remove * @return true if the opperation was completed successfully */ public boolean remove(Grocery entry);
/** * Method to find a specific item in the shopping list * * @param index the index of the item in the shopping list * @return the entry at the specified index * @throws IndexOutOfBoundsException if the index is out of bounds * @throws EmptyCollectionException if the shopping list is empty */ public Grocery find(int index) throws IndexOutOfBoundsException, EmptyCollectionException;
/** * Method to find the index of a Grocery item that is equivalent to the one * provided * * @param entry the item to find * @return the index of the specified item in the shopping list * @throws ElementNotFoundException if the specified item is not in the shopping * list */ public int indexOf(Grocery entry) throws ElementNotFoundException;
/** * Method to determine the existence of a specific item in the shopping list * * @param entry the item to find * @return true if the specified item exists in the shopping list, otherwise * false */ public boolean contains(Grocery entry);
/** * Method to get the size of the shopping list * * @return the size of the shopping list */ public int size();
/** * Method to tell if the shopping list is empty * * @return true if the shopping list is empty, otherwise false */ public boolean isEmpty();
/** * Method to return a string representation of the shopping list * * @return the string representation of the shopping list */ @Override public String toString(); }
Step by Step Solution
There are 3 Steps involved in it
Step: 1
Get Instant Access to Expert-Tailored Solutions
See step-by-step solutions with expert insights and AI powered tools for academic success
Step: 2
Step: 3
Ace Your Homework with AI
Get the answers you need in no time with our AI-driven, step-by-step assistance
Get Started