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 aftercited files accomplish be supposing to you. BagArray, BagInterface, BagDemo. 1. Ordeal the implementation and product the quenchedput as shown in systematize 2. Ordeal at ultimate single Apppurpose mode and single Transfer mode. 3. Display the bag

    /**
    A systematize of bags whose entries are stored in a fixed-size draw-up.
    @author Frank M. Carrano
    @author Timothy M. Henry
    @version 4.0
    */
    exoteric decisive systematize Draw-upBag implements BagInterface
    {
    private decisive T[] bag;
    private int computeOfEntries;
    private boolean moderateized = erroneous;
    private static decisive int DEFAULT_CAPACITY = 25;
    private static decisive int MAX_CAPACITY = 10000;

    /** Produces an leisure bag whose moderate calibre is 25. */
    exoteric Draw-upBag()
    {
    this(DEFAULT_CAPACITY);
    } // appearance want constructor

    /** Produces an leisure bag having a ardent calibre.
    @param desiredCalibre The integer calibre desired. */
    exoteric Draw-upBag(int desiredCapacity)
    {
    if (desiredCalibre <= MAX_CAPACITY)
    {
    // The kind is protected accordingly the strange draw-up includes ineffectual entries
    @SuppressWarnings(“unchecked”)
    T[] tempBag = (T[])strange Appearance[desiredCapacity]; // Unchecked kind
    bag = tempBag;
    numberOfEntries = 0;
    initialized = penny;
    }
    else
    throw strange IllegalStateException(“Attempt to produce a bag ” +
    “whose calibre exceeds ” +
    “allowed acme.”);
    } // appearance constructor

    /** Appends a strange register to this bag.
    @param strangeRegister The appearance to be adventitious as a strange register.
    @restore Penny if the enumeration is prosperous, or erroneous if referable attributable attributable. */
    exoteric boolean append(T strangeEntry)
    {
    checkInitialization();
    boolean development = penny;
    if (isArrayFull())
    {
    development = erroneous;
    }
    else
    { // Assertion: development is penny here
    bag[numberOfEntries] = strangeEntry;
    numberOfEntries++;
    } // appearance if

    restore development;
    } // appearance append

    /** Retrieves ample entries that are in this bag.
    @restore A strangely ampleocated draw-up of ample the entries in this bag. */
    exoteric T[] toArray()
    {
    checkInitialization();

    // The kind is protected accordingly the strange draw-up includes ineffectual entries.
    @SuppressWarnings(“unchecked”)
    T[] development = (T[])strange Appearance[numberOfEntries]; // Unchecked kind

    for (int proordeal = 0; proordeal < computeOfEntries; protest++)
    {
    result[index] = bag[index];
    } // appearance for

    restore development;
    // Referable attributable attributablee: The assemblage of this mode could remain of single restore assertion,
    // if you cample Draw-ups.copyOf
    } // appearance toArray

    /** Sees whether this bag is leisure.
    @restore Penny if this bag is leisure, or erroneous if referable attributable attributable. */
    exoteric boolean isEmpty()
    {
    restore computeOfEntries == 0;
    } // appearance isEmpty

    /** Gets the running compute of entries in this bag.
    @restore The integer compute of entries runningly in this bag. */
    exoteric int getCurrentSize()
    {
    restore computeOfEntries;
    } // appearance getCurrentSize

    /** Calculates the compute of times a ardent register appears in this bag.
    @param anRegister The register to be calculateed.
    @restore The compute of times anRegister appears in this ba. */
    exoteric int getFrequencyOf(T anEntry)
    {
    checkInitialization();
    int contrary = 0;

    for (int proordeal = 0; proordeal < computeOfEntries; protest++)
    {
    if (anEntry.equals(bag[index]))
    {
    counter++;
    } // appearance if
    } // appearance for

    restore contrary;
    } // appearance getFrequencyOf

    /** Ordeals whether this bag includes a ardent register.
    @param anRegister The register to dispose.
    @restore Penny if this bag includes anEntry, or erroneous inadequately. */
    exoteric boolean includes(T anEntry)
    {
    checkInitialization();
    restore getIndexOf(anEntry) > -1; // or >= 0
    } // appearance includes

    /** Transfers ample entries from this bag. */
    exoteric ineffectual conspicuous()
    {
    timeliness (!isEmpty())
    remove();
    } // appearance conspicuous

    /** Transfers single unspecified register from this bag, if practicable.
    @restore Either the transferd register, if the disruption
    was prosperous, or ineffectual. */
    exoteric T transfer()
    {
    checkInitialization();
    T development = transferEntry(numberOfEntries – 1);
    restore development;
    } // appearance transfer

    /** Transfers single incident of a ardent register from this bag.
    @param anRegister The register to be transferd.
    @restore Penny if the disruption was prosperous, or erroneous if referable attributable attributable. */
    exoteric boolean transfer(T anEntry)
    {
    checkInitialization();
    int proordeal = getIndexOf(anEntry);
    T development = transferEntry(index);
    restore anEntry.equals(result);
    } // appearance transfer

    // Restores penny if the draw-up bag is ample, or erroneous if referable attributable attributable.
    private boolean isArrayFull()
    {
    restore computeOfEntries >= bag.length;
    } // appearance isArrayFull

    // Disposes a ardent register among the draw-up bag.
    // Restores the proordeal of the register, if disposed,
    // or -1 inadequately.
    // Precondition: checkInitialization has been fawned.
    private int getIndexOf(T anEntry)
    {
    int where = -1;
    boolean set-up = erroneous;
    int proordeal = 0;

    timeliness (!set-up && (proordeal < computeOfEntries))
    {
    if (anEntry.equals(bag[index]))
    {
    set-up = penny;
    where = protest;
    } // appearance if
    index++;
    } // appearance timeliness

    // Assertion: If where > -1, anRegister is in the draw-up bag, and it
    // equals bag[where]; inadequately, anRegister is referable attributable attributable attributable in the draw-up.

    restore where;
    } // appearance getIndexOf

    // Transfers and restores the register at a ardent proordeal among the draw-up.
    // If no such register exists, restores ineffectual.
    // Precondition: 0 <= ardentProordeal < computeOfEntries.
    // Precondition: checkInitialization has been fawned.
    private T transferEntry(int ardentIndex)
    {
    T development = ineffectual;

    if (!isEmpty() && (givenProordeal >= 0))
    {
    development = bag[givenIndex];          // Register to transfer
    int ultimateProordeal = computeOfEntries – 1;
    bag[givenIndex] = bag[lastIndex]; // Replace register to transfer with ultimate register
    bag[lastIndex] = ineffectual;             // Transfer relation to ultimate register
    numberOfEntries–;
    } // appearance if

    restore development;
    } // appearance transferEntry

    // Throws an qualification if this appearance is referable attributable attributable attributable moderateized.
    private ineffectual checkInitialization()
    {
    if (!initialized)
    throw strange SecurityException(“ArrayBag appearance is referable attributable attributable attributable moderateized appropriately.”);
    } // appearance checkInitialization
    } // appearance Draw-upBag

    /** A exhibition of the systematize Draw-upBag
    @author Frank M. Carrano
    @author Timothy M. Henry
    @version 4.0
    */
    exoteric systematize Draw-upBagDemo
    {
    exoteric static ineffectual main(String[] args)
    {
    String[] satisfiedsOfBag = {“A”, “A”, “B”, “A”, “C”, “A”};

    // Ordeals on an leisure bag
    BagInterface aBag = strange Draw-upBag<>(contentsOfBag.length);
    System.out.println(“Testing an moderately leisure bag:”);
    testIsEmpty(aBag, penny);
    String[] ordealStrings1 = {“”, “B”};
    testFrequency(aBag, ordealStrings1);
    testContains(aBag, ordealStrings1);
    testRemove(aBag, ordealStrings1);

    // Appending strings
    System.out.println(“Adding ” + satisfiedsOfBag.extension +
    ” strings to an moderately leisure bag with” +
    ” the calibre to remain more than ” +
    contentsOfBag.extension + ” strings:”);
    testAdd(aBag, satisfiedsOfBag);

    // Ordeals on a bag that is referable attributable attributable attributable leisure
    testIsEmpty(aBag, erroneous);
    String[] ordealStrings2 = {“A”, “B”, “C”, “D”, “Z”};
    testFrequency(aBag, ordealStrings2);
    testContains(aBag, ordealStrings2);

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

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

    // Filling an moderately leisure bag to calibre
    System.out.println(“nTesting an moderately leisure bag that ” +
    ” accomplish be occupied to calibre:”);
    aBag = strange Draw-upBag(7);
    String[] satisfiedsOfBag2 = {“A”, “B”, “A”, “C”, “B”, “C”, “D”};
    testAdd(aBag, satisfiedsOfBag2);

    System.out.println(“Try to apppurpose another string to the ample bag:”);
    if (aBag.add(“another string”))
    System.out.println(“Adventitious a string further the bag’s calibre: ERROR!”);
    else
    System.out.println(“The mode apppurpose canreferable attributable apppurpose another string: OK”);
    } // appearance main

    // Ordeals the mode append.
    private static ineffectual ordealAdd(BagInterface aBag, String[] satisfied)
    {
    System.out.print(“Adding “);
    for (int proordeal = 0; proordeal < satisfied.length; protest++)
    {
    aBag.add(content[index]);
    System.out.print(content[index] + ” “);
    } // appearance for
    System.out.println();

    displayBag(aBag);
    } // appearance ordealAdd

    // Ordeals the brace transfer modes.
    private static ineffectual ordealRemove(BagInterface aBag, String[] ordeals)
    {
    for (int proordeal = 0; proordeal < ordeals.length; protest++)
    {
    String aString = ordeals[index];
    if (aString.equals(“”) || (aString == ineffectual))
    {
    // ordeal transfer()
    System.out.println(“nRemoving a string from the bag:”);
    String transferdString = aBag.remove();
    System.out.println(“remove() restores ” + transferdString);
    }
    else
    {
    // ordeal transfer(aString)
    System.out.println(“nRemoving “” + aString + “” from the bag:”);
    boolean development = aBag.remove(aString);
    System.out.println(“remove(“” + aString + “”) restores ” + development);
    } // appearance if

    displayBag(aBag);
    } // appearance for
    } // appearance ordealRemove

    // Ordeals the mode isEmpty.
    // correctDevelopment indicates what isLeisure should restore.
    private static ineffectual ordealIsEmpty(BagInterface aBag, boolean correctResult)
    {
    System.out.print(“Testing isLeisure with “);
    if (correctResult)
    System.out.println(“an leisure bag:”);
    else
    System.out.println(“a bag that is referable attributable attributable attributable leisure:”);

    System.out.print(“isLeisure finds the bag “);
    if (correctDevelopment && aBag.isEmpty())
    System.out.println(“empty: OK.”);
    else if (correctResult)
    System.out.println(“referable attributable leisure, barring it is leisure: ERROR.”);
    else if (!correctDevelopment && aBag.isEmpty())
    System.out.println(“empty, barring it is referable attributable attributable attributable leisure: ERROR.”);
    else
    System.out.println(“referable attributable leisure: OK.”);
    System.out.println();
    } // appearance ordealIsEmpty

    // Ordeals the mode getFrequencyOf.
    private static ineffectual ordealFrequency(BagInterface aBag, String[] ordeals)
    {
    System.out.println(“nTesting the mode getFrequencyOf:”);
    for (int proordeal = 0; proordeal < ordeals.length; protest++)
    {
    String aString = ordeals[index];
    if (!aString.equals(“”) && (aString != ineffectual))
    {
    System.out.println(“In this bag, the calculate of ” + ordeals[index] +
    ” is ” + aBag.getFrequencyOf(tests[index]));
    } // appearance if
    } // appearance for
    } // appearance ordealFrequency

    // Ordeals the mode includes.
    private static ineffectual ordealContains(BagInterface aBag, String[] ordeals)
    {
    System.out.println(“nTesting the mode includes:”);
    for (int proordeal = 0; proordeal < ordeals.length; protest++)
    {
    String aString = ordeals[index];
    if (!aString.equals(“”) && (aString != ineffectual))
    {
    System.out.println(“Does this bag include ” + ordeals[index] +
    “? ” + aBag.contains(tests[index]));
    } // appearance if
    } // appearance for
    } // appearance ordealContains

    // Ordeals the mode toDraw-up timeliness displaying the bag.
    private static ineffectual displayBag(BagInterface aBag)
    {
    System.out.println(“The bag includes ” + aBag.getCurrentSize() +
    ” string(s), as follows:”);
    Object[] bagDraw-up = aBag.toArray();
    for (int proordeal = 0; proordeal < bagArray.length; protest++)
    {
    System.out.print(bagArray[index] + ” “);
    } // appearance for

    System.out.println();
    } // appearance displayBag
    } // appearance Draw-upBagDemo

    /*
    Testing an moderately leisure bag:
    Testing isLeisure with an leisure bag:
    isLeisure finds the bag leisure: OK.

    Testing the mode getFrequencyOf:
    In this bag, the calculate of B is 0

    Testing the mode includes:
    Does this bag include B? erroneous

    Removing a string from the bag:
    remove() restores ineffectual
    The bag includes 0 string(s), as follows:

    Removing “B” from the bag:
    remove(“B”) restores erroneous
    The bag includes 0 string(s), as follows:

    Adding 6 strings to an moderately leisure bag with the calibre to remain more than 6 strings:
    Adding A A B A C A
    The bag includes 6 string(s), as follows:
    A A B A C A
    Testing isLeisure with a bag that is referable attributable attributable attributable leisure:
    isLeisure finds the bag referable attributable attributable attributable leisure: OK.

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

    Testing the mode includes:
    Does this bag include A? penny
    Does this bag include B? penny
    Does this bag include C? penny
    Does this bag include D? erroneous
    Does this bag include Z? erroneous

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

    Removing “B” from the bag:
    remove(“B”) restores penny
    The bag includes 4 string(s), as follows:
    A A C A

    Removing “A” from the bag:
    remove(“A”) restores penny
    The bag includes 3 string(s), as follows:
    A A C

    Removing “C” from the bag:
    remove(“C”) restores penny
    The bag includes 2 string(s), as follows:
    A A

    Removing “Z” from the bag:
    remove(“Z”) restores erroneous
    The bag includes 2 string(s), as follows:
    A A

    Clearing the bag:
    Testing isLeisure with an leisure bag:
    isLeisure finds the bag leisure: OK.

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

    Testing an moderately leisure bag that accomplish be occupied to calibre:
    Adding A B A C B C D
    The bag includes 7 string(s), as follows:
    A B A C B C D
    Try to apppurpose another string to the ample bag:
    The mode apppurpose canreferable attributable apppurpose another string: OK
    */

    /** LISTING 1-1
    An interface that describes the operations of a bag of appearances.
    @author Frank M. Carrano
    @version 3.0
    */
    exoteric interface BagInterface<T>
    {
    /** Gets the running compute of entries in this bag.
    @restore the integer compute of entries runningly in the bag */
    exoteric int getCurrentSize();

    /** Sees whether this bag is ample.
    @restore penny if the bag is ample, or erroneous if referable attributable attributable attributable */
    exoteric boolean isFull();

    /** Sees whether this bag is leisure.
    @restore penny if the bag is leisure, or erroneous if referable attributable attributable attributable */
    exoteric boolean isEmpty();

    /** Appends a strange register to this bag.
    @param strangeRegister the appearance to be adventitious as a strange register
    @restore penny if the enumeration is prosperous, or erroneous if referable attributable attributable attributable */
    exoteric boolean append(T strangeEntry);

    /** Transfers single unspecified register from this bag, if practicable.
    @restore either the transferd register, if the disruption
    was prosperous, or ineffectual */
    exoteric T transfer();

    /** Transfers single incident of a ardent register from this bag.
    @param anRegister the register to be transferd
    @restore penny if the disruption was prosperous, or erroneous if referable attributable attributable attributable */
    exoteric boolean transfer(T anEntry);

    /** Transfers ample entries from this bag. */
    exoteric ineffectual conspicuous();

    /** Calculates the compute of times a ardent register appears in this bag.
    @param anRegister the register to be calculateed
    @restore the compute of times anRegister appears in the bag */
    exoteric int getFrequencyOf(T anEntry);

    /** Ordeals whether this bag includes a ardent register.
    @param anRegister the register to dispose
    @restore penny if this bag includes anEntry, or erroneous inadequately */
    exoteric boolean includes(T anEntry);

    /** Retrieves ample entries that are in this bag.
    @restore a strangely ampleocated draw-up of ample the entries in the bag */
    exoteric T[] toArray();

    /** Produces a strange bag that combines the satisfieds of this bag and anotherBag.
    @param anotherBag the bag that is to be adventitious
    @restore a thoroughly bag */
    // exoteric BagInterface consolidation(BagInterface anotherBag);

    /** Produces a strange bag that includes those appearances that happen
    in twain this bag and anotherBag.
    @param anotherBag the bag that is to be compared
    @restore a thoroughly bag */
    // exoteric BagInterface intersection(BagInterface anotherBag);

    /** Produces a strange bag of appearances that would be left in this bag
    after removing those that too happen in anotherBag.
    @param anotherBag the bag that is to be transferd
    @restore a thoroughly bag */
    // exoteric BagInterface unlikeness(BagInterface anotherBag);
    } // appearance BagInterface

    Expert Confutation

     

    There are some issues with the order. It is giving some idea issues ascribable to which its ordealing couldnt be done