Write a class LinkedBag, which includes the following operations:

*Get the current number of entries in this bag.

*See whether this bag is empty.

*Add a new entry to this bag.

*Remove one unspecified entry from this bag, if possible.

*Remove all occurrences of a given entry from this bag.

*Remove all entries from this bag.

*Count the number of times a given entry appears in this bag.

*Test whether this bag contains a given entry.

*Retrieve all entries that are in this bag.

CODES:

LinkedBag: 

/** A class of bags whose entries are stored in a chain of linked nodes. The bag is never full. */ public class LinkedBag implements BagInterface{ 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 private Node firstNode; // Reference to first node private int numberOfEntries; // Default constructor public LinkedBag() { } // end default constructor @Override public int getCurrentSize() { // TODO Auto-generated method stub return 0; } @Override public boolean isEmpty() { // TODO Auto-generated method stub return false; } @Override public boolean add(T newEntry) { // TODO Auto-generated method stub return false; } @Override public T remove() { // TODO Auto-generated method stub return null; } // 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) { Node currentNode; for (currentNode = firstNode;currentNode != null; currentNode = currentNode.next) { if (anEntry==currentNode.data) return currentNode; } // end while return currentNode; } // end getReferenceTo @Override public boolean remove(T anEntry) { // TODO Auto-generated method stub return false; } @Override public void clear() { // TODO Auto-generated method stub } @Override public int getFrequencyOf(T anEntry) { // TODO Auto-generated method stub return 0; } @Override public boolean contains(T anEntry) { // TODO Auto-generated method stub return false; } @Override public T[] toArray() { // TODO Auto-generated method stub return null; } } 

BagInterface: 

/** An interface that describes the operations of a set of objects * This interface will be used for both Project 2 and Project 3*/ public interface BagInterface { /** Gets the current number of entries in this bag. @return The 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 all occurrences 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(); } // end BagInterface 

LinkedBagTest: /** * A test of the constructors and the methods add, toArray, isEmpty, getCurrentSize, * getFrequencyOf, and contains for the class ArrayBag. */ public class LinkedBagTest { public static void main(String[] args) { String[] contentsOfBag = {"One", "One", "Two", "One", "Three", "One"}; // Tests on an empty bag BagInterface aBag = new LinkedBag<>(); System.out.println("Testing an initially empty bag:"); System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); testIsEmpty(aBag, true); String[] testStrings1 = {"", "Two"}; testFrequency(aBag, testStrings1); testContains(aBag, testStrings1); testRemove(aBag, testStrings1); System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++"); System.out.println(); // Adding strings System.out.println("Adding " + contentsOfBag.length + " strings to an initially empty bag with" + " the capacity to hold more than " + contentsOfBag.length + " strings:"); System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); testAdd(aBag, contentsOfBag); // Tests on a bag that is not empty testIsEmpty(aBag, false); String[] testStrings2 = {"One", "Two", "Three", "Four", "XXX"}; testFrequency(aBag, testStrings2); testContains(aBag, testStrings2); // Removing strings String[] testStrings3 = {"", "Two", "One", "Three", "XXX"}; testRemove(aBag, testStrings3); System.out.println(" Clearing the bag:"); aBag.clear(); testIsEmpty(aBag, true); displayBag(aBag); System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++"); System.out.println(); // Filling an initially empty bag to capacity System.out.println(" Testing an initially empty bag that " + " will be filled to capacity:"); System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); aBag = new LinkedBag(); String[] contentsOfBag2 = {"One", "Two", "One", "Three", "Two", "Three", "Four"}; testAdd(aBag, contentsOfBag2); System.out.println("Try to add XXX to the full bag:"); if (aBag.add("XXX")) { System.out.println("Added a string beyond the bag's capacity: OK!"); displayBag(aBag); } else System.out.println("The method add cannot add another string: ERROR!"); } // end main // Tests the method add. private static void testAdd(BagInterface aBag, String[] content) { System.out.print("Adding "); for (int index = 0; index < content.length; index++) { aBag.add(content[index]); System.out.print(content[index] + " "); } // end for System.out.println(); displayBag(aBag); } // end testAdd // Tests the two remove methods. private static void testRemove(BagInterface aBag, String[] tests) { for (int index = 0; index < tests.length; index++) { String aString = tests[index]; if (aString.equals("") || (aString == null)) { // test remove() System.out.println(" Removing a string from the bag:"); String removedString = aBag.remove(); System.out.println("remove() returns " + removedString); } else { // test remove(aString) System.out.println(" Removing \"" + aString + "\" from the bag:"); boolean result = aBag.remove(aString); System.out.println("remove(\"" + aString + "\") returns " + result); } // end if displayBag(aBag); } // end for } // end testRemove // Tests the method isEmpty. // correctResult indicates what isEmpty should return. private static void testIsEmpty(BagInterface aBag, boolean correctResult) { System.out.print("Testing isEmpty with "); if (correctResult) System.out.println("an empty bag:"); else System.out.println("a bag that is not empty:"); System.out.print("isEmpty finds the bag "); if (correctResult && aBag.isEmpty()) System.out.println("empty: OK."); else if (correctResult) System.out.println("not empty, but it is empty: ERROR."); else if (!correctResult && aBag.isEmpty()) System.out.println("empty, but it is not empty: ERROR."); else System.out.println("not empty: OK."); System.out.println(); } // end testIsEmpty // Tests the method getFrequencyOf. private static void testFrequency(BagInterface aBag, String[] tests) { System.out.println(" Testing the method getFrequencyOf:"); for (int index = 0; index < tests.length; index++) { String aString = tests[index]; if (!aString.equals("") && (aString != null)) { System.out.println("In this bag, the count of " + tests[index] + " is " + aBag.getFrequencyOf(tests[index])); } // end if } // end for } // end testFrequency // Tests the method contains. private static void testContains(BagInterface aBag, String[] tests) { System.out.println(" Testing the method contains:"); for (int index = 0; index < tests.length; index++) { String aString = tests[index]; if (!aString.equals("") && (aString != null)) { System.out.println("Does this bag contain " + tests[index] + "? " + aBag.contains(tests[index])); } // end if } // end for } // end testContains // Tests the method toArray while displaying the bag. private static void displayBag(BagInterface aBag) { System.out.println("The bag contains " + aBag.getCurrentSize() + " string(s), as follows:"); Object[] bagArray = aBag.toArray(); for (int index = 0; index < bagArray.length; index++) { System.out.print(bagArray[index] + " "); } // end for System.out.println(); } // end displayBag } // end ArrayBagTest 

EXAMPLE OUTPUT:

Testing an initially empty bag: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Testing isEmpty with an empty bag: isEmpty finds the bag empty: OK.

Testing the method getFrequencyOf: In this bag, the count of Two is 0

Testing the method contains: Does this bag contain Two? false

Removing a string from the bag: remove() returns null The bag contains 0 string(s), as follows:

Removing "Two" from the bag: remove("Two") returns false The bag contains 0 string(s), as follows:

+++++++++++++++++++++++++++++++++++++++++++++++++++

Adding 6 strings to an initially empty bag with the capacity to hold more than 6 strings: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Adding One One Two One Three One The bag contains 6 string(s), as follows: One Three One Two One One Testing isEmpty with a bag that is not empty: isEmpty finds the bag not empty: OK.

Testing the method getFrequencyOf: In this bag, the count of One is 4 In this bag, the count of Two is 1 In this bag, the count of Three is 1 In this bag, the count of Four is 0 In this bag, the count of XXX is 0

Testing the method contains: Does this bag contain One? true Does this bag contain Two? true Does this bag contain Three? true Does this bag contain Four? false Does this bag contain XXX? false

Removing a string from the bag: remove() returns One The bag contains 5 string(s), as follows: Three One Two One One

Removing "Two" from the bag: remove("Two") returns true The bag contains 4 string(s), as follows: One Three One One

Removing "One" from the bag: remove("One") returns true The bag contains 1 string(s), as follows: Three

Removing "Three" from the bag: remove("Three") returns true The bag contains 0 string(s), as follows:

Removing "XXX" from the bag: remove("XXX") returns false The bag contains 0 string(s), as follows:

Clearing the bag: Testing isEmpty with an empty bag: isEmpty finds the bag empty: OK.

The bag contains 0 string(s), as follows:

+++++++++++++++++++++++++++++++++++++++++++++++++++

Testing an initially empty bag that will be filled to capacity: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Adding One Two One Three Two Three Four The bag contains 7 string(s), as follows: Four Three Two Three One Two One Try to add XXX to the full bag: Added a string beyond the bag's capacity: OK! The bag contains 8 string(s), as follows: XXX Four Three Two Three One Two One