Homework Solution: The following files will be provided to you. BagArray, BagInterface, BagDemo. 1. Test the implementation…

    The following files will be provided to you. BagArray, BagInterface, BagDemo. 1. Test the implementation and produce the output as shown in class 2. Test at least one Add method and one Remove method. 3. Display the bag /** A class of bags whose entries are stored in a fixed-size array. @author Frank M. Carrano @author Timothy M. Henry @version 4.0 */ public final class ArrayBag implements BagInterface { private final T[] bag; private int numberOfEntries; private boolean initialized = false; private static final int DEFAULT_CAPACITY = 25; private static final int MAX_CAPACITY = 10000; /** Creates an empty bag whose initial capacity is 25. */ public ArrayBag() { this(DEFAULT_CAPACITY); } // end default constructor /** Creates an empty bag having a given capacity. @param desiredCapacity The integer capacity desired. */ public ArrayBag(int desiredCapacity) { if (desiredCapacity <= MAX_CAPACITY) { // The cast is safe because the new array contains null entries @SuppressWarnings("unchecked") T[] tempBag = (T[])new Object[desiredCapacity]; // Unchecked cast bag = tempBag; numberOfEntries = 0; initialized = true; } else throw new IllegalStateException("Attempt to create a bag " + "whose capacity exceeds " + "allowed maximum."); } // end constructor /** 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) { checkInitialization(); boolean result = true; if (isArrayFull()) { result = false; } else { // Assertion: result is true here bag[numberOfEntries] = newEntry; numberOfEntries++; } // end if return result; } // 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() { checkInitialization(); // The cast is safe because the new array contains null entries. @SuppressWarnings("unchecked") T[] result = (T[])new Object[numberOfEntries]; // Unchecked cast for (int index = 0; index < numberOfEntries; index++) { result[index] = bag[index]; } // end for return result; // Note: The body of this method could consist of one return statement, // if you call Arrays.copyOf } // end toArray /** 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 current number of entries in this bag. @return The integer number of entries currently in this bag. */ public int getCurrentSize() { return numberOfEntries; } // end getCurrentSize /** 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 ba. */ public int getFrequencyOf(T anEntry) { checkInitialization(); int counter = 0; for (int index = 0; index < numberOfEntries; index++) { if (anEntry.equals(bag[index])) { counter++; } // end if } // end for return counter; } // end getFrequencyOf /** Tests whether this bag contains a given entry. @param anEntry The entry to locate. @return True if this bag contains anEntry, or false otherwise. */ public boolean contains(T anEntry) { checkInitialization(); return getIndexOf(anEntry) > -1; // or >= 0 } // end contains /** 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() { checkInitialization(); T result = removeEntry(numberOfEntries - 1); return result; } // end 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) { checkInitialization(); int index = getIndexOf(anEntry); T result = removeEntry(index); return anEntry.equals(result); } // end remove // Returns true if the array bag is full, or false if not. private boolean isArrayFull() { return numberOfEntries >= bag.length; } // end isArrayFull // Locates a given entry within the array bag. // Returns the index of the entry, if located, // or -1 otherwise. // Precondition: checkInitialization has been called. private int getIndexOf(T anEntry) { int where = -1; boolean found = false; int index = 0; while (!found && (index < numberOfEntries)) { if (anEntry.equals(bag[index])) { found = true; where = index; } // end if index++; } // end while // Assertion: If where > -1, anEntry is in the array bag, and it // equals bag[where]; otherwise, anEntry is not in the array. return where; } // end getIndexOf // Removes and returns the entry at a given index within the array. // If no such entry exists, returns null. // Precondition: 0 <= givenIndex < numberOfEntries. // Precondition: checkInitialization has been called. private T removeEntry(int givenIndex) { T result = null; if (!isEmpty() && (givenIndex >= 0)) { result = bag[givenIndex];          // Entry to remove int lastIndex = numberOfEntries - 1; bag[givenIndex] = bag[lastIndex]; // Replace entry to remove with last entry bag[lastIndex] = null;             // Remove reference to last entry numberOfEntries--; } // end if return result; } // end removeEntry // Throws an exception if this object is not initialized. private void checkInitialization() { if (!initialized) throw new SecurityException("ArrayBag object is not initialized properly."); } // end checkInitialization } // end ArrayBag /** A demonstration of the class ArrayBag @author Frank M. Carrano @author Timothy M. Henry @version 4.0 */ public class ArrayBagDemo { public static void main(String[] args) { String[] contentsOfBag = {"A", "A", "B", "A", "C", "A"}; // Tests on an empty bag BagInterface aBag = new ArrayBag<>(contentsOfBag.length); System.out.println("Testing an initially empty bag:"); testIsEmpty(aBag, true); String[] testStrings1 = {"", "B"}; testFrequency(aBag, testStrings1); testContains(aBag, testStrings1); testRemove(aBag, testStrings1); // Adding strings System.out.println("Adding " + contentsOfBag.length + " strings to an initially empty bag with" + " the capacity to hold more than " + contentsOfBag.length + " strings:"); testAdd(aBag, contentsOfBag); // Tests on a bag that is not empty testIsEmpty(aBag, false); String[] testStrings2 = {"A", "B", "C", "D", "Z"}; testFrequency(aBag, testStrings2); testContains(aBag, testStrings2); // Removing strings String[] testStrings3 = {"", "B", "A", "C", "Z"}; testRemove(aBag, testStrings3); System.out.println("nClearing the bag:"); aBag.clear(); testIsEmpty(aBag, true); displayBag(aBag); // Filling an initially empty bag to capacity System.out.println("nTesting an initially empty bag that " + " will be filled to capacity:"); aBag = new ArrayBag(7); String[] contentsOfBag2 = {"A", "B", "A", "C", "B", "C", "D"}; testAdd(aBag, contentsOfBag2); System.out.println("Try to add another string to the full bag:"); if (aBag.add("another string")) System.out.println("Added a string beyond the bag's capacity: ERROR!"); else System.out.println("The method add cannot add another string: OK"); } // 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("nRemoving a string from the bag:"); String removedString = aBag.remove(); System.out.println("remove() returns " + removedString); } else { // test remove(aString) System.out.println("nRemoving "" + 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("nTesting 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("nTesting 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 ArrayBagDemo /* 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 B is 0 Testing the method contains: Does this bag contain B? false Removing a string from the bag: remove() returns null The bag contains 0 string(s), as follows: Removing "B" from the bag: remove("B") 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 A A B A C A The bag contains 6 string(s), as follows: A A B A C A 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 A is 4 In this bag, the count of B is 1 In this bag, the count of C is 1 In this bag, the count of D is 0 In this bag, the count of Z is 0 Testing the method contains: Does this bag contain A? true Does this bag contain B? true Does this bag contain C? true Does this bag contain D? false Does this bag contain Z? false Removing a string from the bag: remove() returns A The bag contains 5 string(s), as follows: A A B A C Removing "B" from the bag: remove("B") returns true The bag contains 4 string(s), as follows: A A C A Removing "A" from the bag: remove("A") returns true The bag contains 3 string(s), as follows: A A C Removing "C" from the bag: remove("C") returns true The bag contains 2 string(s), as follows: A A Removing "Z" from the bag: remove("Z") returns false The bag contains 2 string(s), as follows: A A 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 A B A C B C D The bag contains 7 string(s), as follows: A B A C B C D Try to add another string to the full bag: The method add cannot add another string: OK */ /** LISTING 1-1 An interface that describes the operations of a bag of objects. @author Frank M. Carrano @version 3.0 */ 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 full. @return true if the bag is full, or false if not */ public boolean isFull(); /** 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 this bag contains anEntry, or false otherwise */ 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 */ public T[] toArray(); /** 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 union(BagInterface 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 intersection(BagInterface 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 difference(BagInterface anotherBag); } // end BagInterface

    Expert Answer

     
    There are some issues with the code. It is giving some type issues due to which its testing couldnt be done

    The subjoined files gain be granted to you. BagArray, BagInterface, BagDemo. 1. Experience the implementation and consequence the quenchedput as shown in arrange 2. Experience at smallest individual Supplement rule and individual Displace rule. 3. Display the bag

    /**
    A arrange of bags whose entries are stored in a fixed-size marshal.
    @author Frank M. Carrano
    @author Timothy M. Henry
    @version 4.0
    */
    generally-known decisive arrange MarshalBag implements BagInterface
    {
    private decisive T[] bag;
    private int sumOfEntries;
    private boolean judiciousized = dishonorable;
    private static decisive int DEFAULT_CAPACITY = 25;
    private static decisive int MAX_CAPACITY = 10000;

    /** Begets an emptiness bag whose judicious accommodation is 25. */
    generally-known MarshalBag()
    {
    this(DEFAULT_CAPACITY);
    } // design want constructor

    /** Begets an emptiness bag having a abandoned accommodation.
    @param desiredAccommodation The integer accommodation desired. */
    generally-known MarshalBag(int desiredCapacity)
    {
    if (desiredAccommodation <= MAX_CAPACITY)
    {
    // The figure is certain accordingly the odd marshal incloses vain entries
    @SuppressWarnings(“unchecked”)
    T[] tempBag = (T[])odd Design[desiredCapacity]; // Unchecked figure
    bag = tempBag;
    numberOfEntries = 0;
    initialized = gentleman;
    }
    else
    throw odd IllegalStateException(“Attempt to beget a bag ” +
    “whose accommodation exceeds ” +
    “allowed consummation.”);
    } // design constructor

    /** Supplements a odd memorandum to this bag.
    @param oddMemorandum The design to be assumed as a odd memorandum.
    @recompense Gentleman if the observation is prosperous, or dishonorable if referable attributable attributable. */
    generally-known boolean supplement(T oddEntry)
    {
    checkInitialization();
    boolean conclusion = gentleman;
    if (isArrayFull())
    {
    conclusion = dishonorable;
    }
    else
    { // Assertion: conclusion is gentleman here
    bag[numberOfEntries] = oddEntry;
    numberOfEntries++;
    } // design if

    recompense conclusion;
    } // design supplement

    /** Retrieves unmeasured entries that are in this bag.
    @recompense A oddly unmeasuredocated marshal of unmeasured the entries in this bag. */
    generally-known T[] toArray()
    {
    checkInitialization();

    // The figure is certain accordingly the odd marshal incloses vain entries.
    @SuppressWarnings(“unchecked”)
    T[] conclusion = (T[])odd Design[numberOfEntries]; // Unchecked figure

    for (int renunciation = 0; renunciation < sumOfEntries; renunciation++)
    {
    result[index] = bag[index];
    } // design for

    recompense conclusion;
    // Referable attributable attributablee: The assemblage of this rule could await of individual recompense assertion,
    // if you cunmeasured Marshals.copyOf
    } // design toArray

    /** Sees whether this bag is emptiness.
    @recompense Gentleman if this bag is emptiness, or dishonorable if referable attributable attributable. */
    generally-known boolean isEmpty()
    {
    recompense sumOfEntries == 0;
    } // design isEmpty

    /** Gets the prevalent sum of entries in this bag.
    @recompense The integer sum of entries prevalently in this bag. */
    generally-known int getCurrentSize()
    {
    recompense sumOfEntries;
    } // design getCurrentSize

    /** Estimates the sum of times a abandoned memorandum appears in this bag.
    @param anMemorandum The memorandum to be estimateed.
    @recompense The sum of times anMemorandum appears in this ba. */
    generally-known int getFrequencyOf(T anEntry)
    {
    checkInitialization();
    int contrary = 0;

    for (int renunciation = 0; renunciation < sumOfEntries; renunciation++)
    {
    if (anEntry.equals(bag[index]))
    {
    counter++;
    } // design if
    } // design for

    recompense contrary;
    } // design getFrequencyOf

    /** Experiences whether this bag incloses a abandoned memorandum.
    @param anMemorandum The memorandum to establish.
    @recompense Gentleman if this bag incloses anEntry, or dishonorable differently. */
    generally-known boolean incloses(T anEntry)
    {
    checkInitialization();
    recompense getIndexOf(anEntry) > -1; // or >= 0
    } // design incloses

    /** Displaces unmeasured entries from this bag. */
    generally-known invalid disentangled()
    {
    while (!isEmpty())
    remove();
    } // design disentangled

    /** Displaces individual unspecified memorandum from this bag, if potential.
    @recompense Either the displaced memorandum, if the resistance
    was prosperous, or vain. */
    generally-known T displace()
    {
    checkInitialization();
    T conclusion = displaceEntry(numberOfEntries – 1);
    recompense conclusion;
    } // design displace

    /** Displaces individual transaction of a abandoned memorandum from this bag.
    @param anMemorandum The memorandum to be displaced.
    @recompense Gentleman if the resistance was prosperous, or dishonorable if referable attributable attributable. */
    generally-known boolean displace(T anEntry)
    {
    checkInitialization();
    int renunciation = getIndexOf(anEntry);
    T conclusion = displaceEntry(index);
    recompense anEntry.equals(result);
    } // design displace

    // Recompenses gentleman if the marshal bag is unmeasured, or dishonorable if referable attributable attributable.
    private boolean isArrayFull()
    {
    recompense sumOfEntries >= bag.length;
    } // design isArrayFull

    // Establishs a abandoned memorandum among the marshal bag.
    // Recompenses the renunciation of the memorandum, if establishd,
    // or -1 differently.
    // Precondition: checkInitialization has been persuadeed.
    private int getIndexOf(T anEntry)
    {
    int where = -1;
    boolean build = dishonorable;
    int renunciation = 0;

    while (!build && (renunciation < sumOfEntries))
    {
    if (anEntry.equals(bag[index]))
    {
    build = gentleman;
    where = renunciation;
    } // design if
    index++;
    } // design while

    // Assertion: If where > -1, anMemorandum is in the marshal bag, and it
    // equals bag[where]; differently, anMemorandum is referable attributable attributable attributable in the marshal.

    recompense where;
    } // design getIndexOf

    // Displaces and recompenses the memorandum at a abandoned renunciation among the marshal.
    // If no such memorandum exists, recompenses vain.
    // Precondition: 0 <= abandonedRenunciation < sumOfEntries.
    // Precondition: checkInitialization has been persuadeed.
    private T displaceEntry(int abandonedIndex)
    {
    T conclusion = vain;

    if (!isEmpty() && (givenRenunciation >= 0))
    {
    conclusion = bag[givenIndex];          // Memorandum to displace
    int terminalRenunciation = sumOfEntries – 1;
    bag[givenIndex] = bag[lastIndex]; // Replace memorandum to displace with terminal memorandum
    bag[lastIndex] = vain;             // Displace entireusion to terminal memorandum
    numberOfEntries–;
    } // design if

    recompense conclusion;
    } // design displaceEntry

    // Throws an qualification if this design is referable attributable attributable attributable judiciousized.
    private invalid checkInitialization()
    {
    if (!initialized)
    throw odd SecurityException(“ArrayBag design is referable attributable attributable attributable judiciousized properly.”);
    } // design checkInitialization
    } // design MarshalBag

    /** A pretext of the arrange MarshalBag
    @author Frank M. Carrano
    @author Timothy M. Henry
    @version 4.0
    */
    generally-known arrange MarshalBagDemo
    {
    generally-known static invalid ocean(String[] args)
    {
    String[] resignedsOfBag = {“A”, “A”, “B”, “A”, “C”, “A”};

    // Experiences on an emptiness bag
    BagInterface aBag = odd MarshalBag<>(contentsOfBag.length);
    System.out.println(“Testing an judiciously emptiness bag:”);
    testIsEmpty(aBag, gentleman);
    String[] experienceStrings1 = {“”, “B”};
    testFrequency(aBag, experienceStrings1);
    testContains(aBag, experienceStrings1);
    testRemove(aBag, experienceStrings1);

    // Supplementing strings
    System.out.println(“Adding ” + resignedsOfBag.tediousness +
    ” strings to an judiciously emptiness bag with” +
    ” the accommodation to await over than ” +
    contentsOfBag.tediousness + ” strings:”);
    testAdd(aBag, resignedsOfBag);

    // Experiences on a bag that is referable attributable attributable attributable emptiness
    testIsEmpty(aBag, dishonorable);
    String[] experienceStrings2 = {“A”, “B”, “C”, “D”, “Z”};
    testFrequency(aBag, experienceStrings2);
    testContains(aBag, experienceStrings2);

    // Removing strings
    String[] experienceStrings3 = {“”, “B”, “A”, “C”, “Z”};
    testRemove(aBag, experienceStrings3);

    System.out.println(“nClearing the bag:”);
    aBag.clear();
    testIsEmpty(aBag, gentleman);
    displayBag(aBag);

    // Filling an judiciously emptiness bag to accommodation
    System.out.println(“nTesting an judiciously emptiness bag that ” +
    ” gain be assiduous to accommodation:”);
    aBag = odd MarshalBag(7);
    String[] resignedsOfBag2 = {“A”, “B”, “A”, “C”, “B”, “C”, “D”};
    testAdd(aBag, resignedsOfBag2);

    System.out.println(“Try to supplement another string to the unmeasured bag:”);
    if (aBag.add(“another string”))
    System.out.println(“Assumed a string further the bag’s accommodation: ERROR!”);
    else
    System.out.println(“The rule supplement canreferable attributable supplement another string: OK”);
    } // design ocean

    // Experiences the rule supplement.
    private static invalid experienceAdd(BagInterface aBag, String[] resigned)
    {
    System.out.print(“Adding “);
    for (int renunciation = 0; renunciation < resigned.length; renunciation++)
    {
    aBag.add(content[index]);
    System.out.print(content[index] + ” “);
    } // design for
    System.out.println();

    displayBag(aBag);
    } // design experienceAdd

    // Experiences the span displace rules.
    private static invalid experienceRemove(BagInterface aBag, String[] experiences)
    {
    for (int renunciation = 0; renunciation < experiences.length; renunciation++)
    {
    String aString = experiences[index];
    if (aString.equals(“”) || (aString == vain))
    {
    // experience displace()
    System.out.println(“nRemoving a string from the bag:”);
    String displacedString = aBag.remove();
    System.out.println(“remove() recompenses ” + displacedString);
    }
    else
    {
    // experience displace(aString)
    System.out.println(“nRemoving “” + aString + “” from the bag:”);
    boolean conclusion = aBag.remove(aString);
    System.out.println(“remove(“” + aString + “”) recompenses ” + conclusion);
    } // design if

    displayBag(aBag);
    } // design for
    } // design experienceRemove

    // Experiences the rule isEmpty.
    // correctConclusion indicates what isEmptiness should recompense.
    private static invalid experienceIsEmpty(BagInterface aBag, boolean correctResult)
    {
    System.out.print(“Testing isEmptiness with “);
    if (correctResult)
    System.out.println(“an emptiness bag:”);
    else
    System.out.println(“a bag that is referable attributable attributable attributable emptiness:”);

    System.out.print(“isEmptiness finds the bag “);
    if (correctConclusion && aBag.isEmpty())
    System.out.println(“empty: OK.”);
    else if (correctResult)
    System.out.println(“referable attributable emptiness, still it is emptiness: ERROR.”);
    else if (!correctConclusion && aBag.isEmpty())
    System.out.println(“empty, still it is referable attributable attributable attributable emptiness: ERROR.”);
    else
    System.out.println(“referable attributable emptiness: OK.”);
    System.out.println();
    } // design experienceIsEmpty

    // Experiences the rule getFrequencyOf.
    private static invalid experienceFrequency(BagInterface aBag, String[] experiences)
    {
    System.out.println(“nTesting the rule getFrequencyOf:”);
    for (int renunciation = 0; renunciation < experiences.length; renunciation++)
    {
    String aString = experiences[index];
    if (!aString.equals(“”) && (aString != vain))
    {
    System.out.println(“In this bag, the estimate of ” + experiences[index] +
    ” is ” + aBag.getFrequencyOf(tests[index]));
    } // design if
    } // design for
    } // design experienceFrequency

    // Experiences the rule incloses.
    private static invalid experienceContains(BagInterface aBag, String[] experiences)
    {
    System.out.println(“nTesting the rule incloses:”);
    for (int renunciation = 0; renunciation < experiences.length; renunciation++)
    {
    String aString = experiences[index];
    if (!aString.equals(“”) && (aString != vain))
    {
    System.out.println(“Does this bag inclose ” + experiences[index] +
    “? ” + aBag.contains(tests[index]));
    } // design if
    } // design for
    } // design experienceContains

    // Experiences the rule toMarshal while displaying the bag.
    private static invalid displayBag(BagInterface aBag)
    {
    System.out.println(“The bag incloses ” + aBag.getCurrentSize() +
    ” string(s), as follows:”);
    Object[] bagMarshal = aBag.toArray();
    for (int renunciation = 0; renunciation < bagArray.length; renunciation++)
    {
    System.out.print(bagArray[index] + ” “);
    } // design for

    System.out.println();
    } // design displayBag
    } // design MarshalBagDemo

    /*
    Testing an judiciously emptiness bag:
    Testing isEmptiness with an emptiness bag:
    isEmptiness finds the bag emptiness: OK.

    Testing the rule getFrequencyOf:
    In this bag, the estimate of B is 0

    Testing the rule incloses:
    Does this bag inclose B? dishonorable

    Removing a string from the bag:
    remove() recompenses vain
    The bag incloses 0 string(s), as follows:

    Removing “B” from the bag:
    remove(“B”) recompenses dishonorable
    The bag incloses 0 string(s), as follows:

    Adding 6 strings to an judiciously emptiness bag with the accommodation to await over than 6 strings:
    Adding A A B A C A
    The bag incloses 6 string(s), as follows:
    A A B A C A
    Testing isEmptiness with a bag that is referable attributable attributable attributable emptiness:
    isEmptiness finds the bag referable attributable attributable attributable emptiness: OK.

    Testing the rule getFrequencyOf:
    In this bag, the estimate of A is 4
    In this bag, the estimate of B is 1
    In this bag, the estimate of C is 1
    In this bag, the estimate of D is 0
    In this bag, the estimate of Z is 0

    Testing the rule incloses:
    Does this bag inclose A? gentleman
    Does this bag inclose B? gentleman
    Does this bag inclose C? gentleman
    Does this bag inclose D? dishonorable
    Does this bag inclose Z? dishonorable

    Removing a string from the bag:
    remove() recompenses A
    The bag incloses 5 string(s), as follows:
    A A B A C

    Removing “B” from the bag:
    remove(“B”) recompenses gentleman
    The bag incloses 4 string(s), as follows:
    A A C A

    Removing “A” from the bag:
    remove(“A”) recompenses gentleman
    The bag incloses 3 string(s), as follows:
    A A C

    Removing “C” from the bag:
    remove(“C”) recompenses gentleman
    The bag incloses 2 string(s), as follows:
    A A

    Removing “Z” from the bag:
    remove(“Z”) recompenses dishonorable
    The bag incloses 2 string(s), as follows:
    A A

    Clearing the bag:
    Testing isEmptiness with an emptiness bag:
    isEmptiness finds the bag emptiness: OK.

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

    Testing an judiciously emptiness bag that gain be assiduous to accommodation:
    Adding A B A C B C D
    The bag incloses 7 string(s), as follows:
    A B A C B C D
    Try to supplement another string to the unmeasured bag:
    The rule supplement canreferable attributable supplement another string: OK
    */

    /** LISTING 1-1
    An interface that describes the operations of a bag of designs.
    @author Frank M. Carrano
    @version 3.0
    */
    generally-known interface BagInterface<T>
    {
    /** Gets the prevalent sum of entries in this bag.
    @recompense the integer sum of entries prevalently in the bag */
    generally-known int getCurrentSize();

    /** Sees whether this bag is unmeasured.
    @recompense gentleman if the bag is unmeasured, or dishonorable if referable attributable attributable attributable */
    generally-known boolean isFull();

    /** Sees whether this bag is emptiness.
    @recompense gentleman if the bag is emptiness, or dishonorable if referable attributable attributable attributable */
    generally-known boolean isEmpty();

    /** Supplements a odd memorandum to this bag.
    @param oddMemorandum the design to be assumed as a odd memorandum
    @recompense gentleman if the observation is prosperous, or dishonorable if referable attributable attributable attributable */
    generally-known boolean supplement(T oddEntry);

    /** Displaces individual unspecified memorandum from this bag, if potential.
    @recompense either the displaced memorandum, if the resistance
    was prosperous, or vain */
    generally-known T displace();

    /** Displaces individual transaction of a abandoned memorandum from this bag.
    @param anMemorandum the memorandum to be displaced
    @recompense gentleman if the resistance was prosperous, or dishonorable if referable attributable attributable attributable */
    generally-known boolean displace(T anEntry);

    /** Displaces unmeasured entries from this bag. */
    generally-known invalid disentangled();

    /** Estimates the sum of times a abandoned memorandum appears in this bag.
    @param anMemorandum the memorandum to be estimateed
    @recompense the sum of times anMemorandum appears in the bag */
    generally-known int getFrequencyOf(T anEntry);

    /** Experiences whether this bag incloses a abandoned memorandum.
    @param anMemorandum the memorandum to establish
    @recompense gentleman if this bag incloses anEntry, or dishonorable differently */
    generally-known boolean incloses(T anEntry);

    /** Retrieves unmeasured entries that are in this bag.
    @recompense a oddly unmeasuredocated marshal of unmeasured the entries in the bag */
    generally-known T[] toArray();

    /** Begets a odd bag that combines the resigneds of this bag and anotherBag.
    @param anotherBag the bag that is to be assumed
    @recompense a entirely bag */
    // generally-known BagInterface conjunction(BagInterface anotherBag);

    /** Begets a odd bag that incloses those designs that happen
    in twain this bag and anotherBag.
    @param anotherBag the bag that is to be compared
    @recompense a entirely bag */
    // generally-known BagInterface intersection(BagInterface anotherBag);

    /** Begets a odd bag of designs that would be left in this bag
    after removing those that as-well happen in anotherBag.
    @param anotherBag the bag that is to be displaced
    @recompense a entirely bag */
    // generally-known BagInterface variety(BagInterface anotherBag);
    } // design BagInterface

    Expert Counter-argument

     

    There are some issues with the jurisprudence. It is giving some archearchetype issues due to which its experienceing couldnt be done