Question

You are going to set up a small shopping system, where you are going to implement a "shopping bag" subject to the following specifications:

• Each item that will be placed in the bag needs three pieces of data included: a descriptive name, an item code (2 letters followed by two numbers), and price (in US dollars).
• You will implement items as a separate class, where these three properties are private, and there are mutators and accessors for all three properties, as well as default, conversion and copy constructors.
• You will use the linked list implementation of a bag, and you can find the bag's source code here and the demonstration class here. (go to https://home.adelphi.edu/~siegfried/cs273/assignments/html for the links).
• There are 5 operations that you can do:
  • You can add an item to the bag (you need to give it a descriptivename, item code and price
  • You can remove one item from the bag and show whether there are any others of that item in the bag.
  • You can remove all of a type of item from the bag.
  • You show that you have the item and there are x of that item in the bag.
  • You can show all the items in the bag.

Make sure your code is well documented. Use the methods that are available in the Bag class.

Source code for Assignment #

/**
   An interface that describes the operations of a bag of objects.
   @author Frank M. Carrano
   @author Timothy M. Henry
   @version 4.1
*/
public interface BagInterface<T>
{
        /** Gets the current number of entries in this bag.
                 @return  The integer number of entries currently in the bag. */
        public int getCurrentSize();
        
        /** Sees whether this bag is empty.
                 @return  True if the bag is empty, or false if not. */
        public boolean isEmpty();
        
        /** Adds a new entry to this bag.
            @param newEntry  The object to be added as a new entry.
            @return  True if the addition is successful, or false if not. */
        public boolean add(T newEntry);

        /** Removes one unspecified entry from this bag, if possible.
       @return  Either the removed entry, if the removal.
                was successful, or null. */
        public T remove();
   
        /** Removes one occurrence of a given entry from this bag.
       @param anEntry  The entry to be removed.
       @return  True if the removal was successful, or false if not. */
   public boolean remove(T anEntry);
        
        /** Removes all entries from this bag. */
        public void clear();
        
        /** Counts the number of times a given entry appears in this bag.
                 @param anEntry  The entry to be counted.
                 @return  The number of times anEntry appears in the bag. */
        public int getFrequencyOf(T anEntry);
        
        /** Tests whether this bag contains a given entry.
                 @param anEntry  The entry to locate.
                 @return  True if the bag contains anEntry, or false if not. */
        public boolean contains(T anEntry);
   
        /** Retrieves all entries that are in this bag.
                 @return  A newly allocated array of all the entries in the bag.
                Note: If the bag is empty, the returned array is empty. */
        public T[] toArray();
//      public <T> T[] toArray();  // Alternate
//      public Object[] toArray(); // Alternate

   /** Creates a new bag that combines the contents of this bag
       and anotherBag.
       @param anotherBag  The bag that is to be added.
       @return  A combined bag. */
   //   public BagInterface<T> union(BagInterface<T> anotherBag);
   
   /** Creates a new bag that contains those objects that occur
       in both this bag and anotherBag.
       @param anotherBag  The bag that is to be compared.
       @return  A combined bag. */
   //   public BagInterface<T> intersection(BagInterface<T> anotherBag);
   
   /** Creates a new bag of objects that would be left in this bag
       after removing those that also occur in anotherBag.
       @param anotherBag  The bag that is to be removed.
       @return  A combined bag. */
   //   public BagInterface<T> difference(BagInterface<T> anotherBag);
} // end BagInterface
Bag Class
public final class LinkedBag<T> implements BagInterface<T>
{
        private Node firstNode;       // Reference to first node
        private int numberOfEntries;

        public LinkedBag()
        {
                firstNode = null;
      numberOfEntries = 0;
        } // end default constructor

        /** Sees whether this bag is empty.
            @return  True if this bag is empty, or false if not. */
        public boolean isEmpty() 
        {
                return numberOfEntries == 0;
        } // end isEmpty

        /** Gets the number of entries currently in this bag.
            @return  The integer number of entries currently in this bag. */
        public int getCurrentSize() 
        {
                return numberOfEntries;
        } // end getCurrentSize

        /** Adds a new entry to this bag.
            @param newEntry  The object to be added as a new entry
            @return  True if the addition is successful, or false if not. */
        public boolean add(T newEntry)                // OutOfMemoryError possible
        {
      // Add to beginning of chain:
                Node newNode = new Node(newEntry);
                newNode.next = firstNode; // Make new node reference rest of chain
                                // (firstNode is null if chain is empty)        
      firstNode = newNode;      // New node is at beginning of chain
                numberOfEntries++;
      
                return true;
        } // end add

        /** Retrieves all entries that are in this bag.
            @return  A newly allocated array of all the entries in this bag. */
        public T[] toArray()
        {
      // The cast is safe because the new array contains null entries
      @SuppressWarnings("unchecked")
      T[] result = (T[])new Object[numberOfEntries]; // Unchecked cast

      int index = 0;
      Node currentNode = firstNode;
      while ((index < numberOfEntries) && (currentNode != null))
      {
         result[index] = currentNode.data;
         index++;
         currentNode = currentNode.next;
      } // end while
        
                return result;
        } // end toArray

        /** Counts the number of times a given entry appears in this bag.
                 @param anEntry  The entry to be counted.
                 @return  The number of times anEntry appears in this bag. */
        public int getFrequencyOf(T anEntry) 
        {
                int frequency = 0;

      int counter = 0;
      Node currentNode = firstNode;
      while ((counter < numberOfEntries) && (currentNode != null))
      {
         if (anEntry.equals(currentNode.data))
         {
            frequency++;
         } // end if
         
         counter++;
         currentNode = currentNode.next;
      } // end while

                return frequency;
        } // end getFrequencyOf

        /** Tests whether this bag contains a given entry.
                 @param anEntry  The entry to locate.
                 @return  True if the bag contains anEntry, or false otherwise. */
        public boolean contains(T anEntry)
        {
      boolean found = false;
      Node currentNode = firstNode;
      
      while (!found && (currentNode != null))
      {
         if (anEntry.equals(currentNode.data))
            found = true;
         else
            currentNode = currentNode.next;
      } // end while    
      
      return found;
   } // end contains
   
        // Locates a given entry within this bag.
        // Returns a reference to the node containing the entry, if located,
        // or null otherwise.
        private Node getReferenceTo(T anEntry)
        {
                boolean found = false;
                Node currentNode = firstNode;
                
                while (!found && (currentNode != null))
                {
                        if (anEntry.equals(currentNode.data))
                                found = true;
                        else
                                currentNode = currentNode.next;
                } // end while
     
                return currentNode;
        } // end getReferenceTo

   /** Removes all entries from this bag. */
        public void clear() 
        {
                while (!isEmpty()) 
         remove();
        } // end clear
        
        /** Removes one unspecified entry from this bag, if possible.
       @return  Either the removed entry, if the removal
                was successful, or null. */
        public T remove()
        {
                T result = null;
      if (firstNode != null)
      {
         result = firstNode.data; 
         firstNode = firstNode.next; // Remove first node from chain
         numberOfEntries--;
      } // end if

                return result;
        } // end remove
        
        /** Removes one occurrence of a given entry from this bag, if possible.
       @param anEntry  The entry to be removed.
       @return  True if the removal was successful, or false otherwise. */
   public boolean remove(T anEntry) 
        {
                boolean result = false;
      Node nodeN = getReferenceTo(anEntry);
      
      if (nodeN != null)
      {
         nodeN.data = firstNode.data; // Replace located entry with entry in first node
         
         firstNode = firstNode.next;  // Remove first node
         numberOfEntries--;
         
         result = true;
      } // end if
         
                return result;
        } // end remove

        private class Node 
        {
          private T    data; // Entry in bag
          private Node next; // Link to next node

                private Node(T dataPortion)
                {
                        this(dataPortion, null);        
                } // end constructor
                
                private Node(T dataPortion, Node nextNode)
                {
                        data = dataPortion;
                        next = nextNode;        
                } // end constructor
        } // end Node
} // end LinkedBag

Answer 1

Please find below your shopping bag class:

import java.math.BigDecimal;

/**

* Implementation of the Shopping Bag. You can add an item, remove an item, remove all occurrences of an item, print * an item and print all the items present in the shopping bag.
* @author enter your name here
*
*/
public class ShoppingBag {
   LinkedBag<Item> shoppingBag;

   /**
   * Default Constructor for Shopping Bag
   */
   public ShoppingBag() {
       shoppingBag = new LinkedBag<>();
   }

   /**
   * Method to add an item to the shopping bag
   *
   * @param itemName
   * @param itemCode
   * @param price
   * @return item is added or not
   */
   public boolean add(String itemName, String itemCode, String price) {
       boolean isAdded = false;
       if (!checkContentValid(itemName, itemCode, price)) {
           System.out.println("Invalid Data obtained");
           return isAdded;
       }
       Item item = new Item(itemName, itemCode, price); // Create an item
       if (item != null) {
           isAdded = shoppingBag.add(item);
       }
       return isAdded;
   }

   /**
   * Remove an occurrence of item from the bag
   *
   * @param item
   * to be removed
   * @return the total remaining occurrences of that item in the bag
   */
   public int remove(Item item) {
       boolean result = shoppingBag.remove(item); // Removing the first
                                                   // occurrence of the item
                                                   // (if exists)
       if (result) {
           return shoppingBag.getFrequencyOf(item); // return the remaining
                                                       // occurrences of item
                                                       // in the bag
       }
       return 0; // if item is not present in the bag, return 0
   }

   /**
   * Remove all occurrences of the item from the bag
   *
   * @param item
   * @return all occurrences removed or not
   */
   public boolean removeAll(Item item) {
       // Removing the first occurrence of the item (if exists)
       boolean isRemoved = shoppingBag.remove(item);
       // loop until all occurrences are removed (if exists)
       while (isRemoved && shoppingBag.getFrequencyOf(item) > 0) {
           // remove the subsequent occurrences (if exists)
           isRemoved = shoppingBag.remove(item);
       }
       // if all occurrences are not removed, return false
       return isRemoved;
   }

   /**
   * Clears the shopping bag
   */
   public void removeAll() {
       shoppingBag.remove();
   }

   /**
   * Display an item and its total occurrences in the bag
   *
   * @param item
   * to be displayed
   */
   public void show(Item item) {
       // Check if item exists in the bag
       if (shoppingBag.contains(item)) {
           System.out.println("Item Found " + item + ", Frequency: " + shoppingBag.getFrequencyOf(item));
       }
       System.out.println("Unable to Find " + item);
   }

   /**
   * Prints all the items present in the shopping bag
   */
   public void showAll() {
       System.out.println("The bag contains the following item(s):");
       // Get all items in the bag
       Object[] bagArray = shoppingBag.toArray();
       for (Object element : bagArray) {
           System.out.print(element + " ");
       }

       System.out.println();
   }

   private boolean checkContentValid(String itemName, String itemCode, String price) {
       boolean result = true;
       // Check if name is valid
       if (itemName == null || itemName.isEmpty()) {
           System.out.println("Item Name cannot be empty");
           result = false;
       }
       // Check if code is valid
       if (itemCode == null || !itemCode.matches("[a-zA-Z]{2}[0-9]{2}")) {
           System.out.println("Invalid Item Code");
           result = false;
       }
       // Check if price is valid
       try {
           BigDecimal priceValue = new BigDecimal(price);
           if (priceValue.compareTo(BigDecimal.ZERO) < 0) {
               System.out.println("Price should be greater than zero");
               result = false;
           }
       } catch (Exception e) {
           System.out.println("Price is invalid");
           result = false;
       }
       return result;
   }
}

And your item class:

import java.math.BigDecimal;

public class Item {
   private String itemName;
   private String itemCode;
   private BigDecimal price;

   /**
   * Default Constructor for Item
   */
   public Item() {
   }

   /**
   * Creates an item with the given name, code and price
   *
   * @param itemName
   * @param itemCode
   * @param price
   */
   public Item(String itemName, String itemCode, String price) {
       this.itemName = itemName;
       this.itemCode = itemCode;
       this.price = new BigDecimal(price);
   }

   /**
   * Copy an item to another item
   *
   * @param item
   */
   public Item(Item item) {
       if (item != null) {
           itemName = item.itemName;
           itemCode = item.itemCode;
           price = new BigDecimal(item.price.toString());
       }
   }

   @Override
   public String toString() {
       return "Item [itemName=" + itemName + ", itemCode=" + itemCode + ", price=" + price + "]";
   }

   /**
   * @return item name
   */
   public String getItemName() {
       return itemName;
   }

   /**
   * @param itemName
   */
   public void setItemName(String itemName) {
       this.itemName = itemName;
   }

   /**
   * @return
   */
   public String getItemCode() {
       return itemCode;
   }

   /**
   * @param itemCode
   */
   public void setItemCode(String itemCode) {
       this.itemCode = itemCode;
   }

   /**
   * @return
   */
   public BigDecimal getPrice() {
       return price;
   }

   /**
   * @param price
   */
   public void setPrice(BigDecimal price) {
       this.price = price;
   }

}