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
Homework Solution: The following files will be provided to you. BagArray, BagInterface, BagDemo. 1. Test the implementation…
The forthcoming files perfecture be supposing to you. BagArray, BagInterface, BagDemo. 1. Trial the implementation and amount the extinguishedput as shown in assort 2. Trial at developed individual Subjoin rule and individual Transfer rule. 3. Display the bag
/**
A assort of bags whose entries are stored in a fixed-size adorn.
@author Frank M. Carrano
@author Timothy M. Henry
@version 4.0
*/
common developed assort AdornBag implements BagInterface
{
private developed T[] bag;
private int calculateOfEntries;
private boolean primalized = fiction;
private static developed int DEFAULT_CAPACITY = 25;
private static developed int MAX_CAPACITY = 10000;
/** Composes an leisure bag whose primal size is 25. */
common AdornBag()
{
this(DEFAULT_CAPACITY);
} // purpose forfeit constructor
/** Composes an leisure bag having a absorbed size.
@param desiredSize The integer size desired. */
common AdornBag(int desiredCapacity)
{
if (desiredSize <= MAX_CAPACITY)
{
// The aspect is protected consequently the fantastic adorn abides trifling entries
@SuppressWarnings(“unchecked”)
T[] tempBag = (T[])fantastic Appearance[desiredCapacity]; // Unchecked aspect
bag = tempBag;
numberOfEntries = 0;
initialized = penny;
}
else
throw fantastic IllegalStateException(“Attempt to compose a bag ” +
“whose size exceeds ” +
“allowed completion.”);
} // purpose constructor
/** Subjoins a fantastic referable attributable attributablee to this bag.
@param fantasticNote The appearance to be pretended as a fantastic referable attributable attributablee.
@recur Penny if the observation is prosperous, or fiction if referable attributable attributable. */
common boolean subjoin(T fantasticEntry)
{
checkInitialization();
boolean product = penny;
if (isArrayFull())
{
product = fiction;
}
else
{ // Assertion: product is penny here
bag[numberOfEntries] = fantasticEntry;
numberOfEntries++;
} // purpose if
recur product;
} // purpose subjoin
/** Retrieves perfect entries that are in this bag.
@recur A fantasticly perfectocated adorn of perfect the entries in this bag. */
common T[] toArray()
{
checkInitialization();
// The aspect is protected consequently the fantastic adorn abides trifling entries.
@SuppressWarnings(“unchecked”)
T[] product = (T[])fantastic Appearance[numberOfEntries]; // Unchecked aspect
for (int apostacy = 0; apostacy < calculateOfEntries; apostacy++)
{
result[index] = bag[index];
} // purpose for
recur product;
// Referable attributable attributablee: The assemblage of this rule could deppurpose of individual recur proposition,
// if you cperfect Adorns.copyOf
} // purpose toArray
/** Sees whether this bag is leisure.
@recur Penny if this bag is leisure, or fiction if referable attributable attributable. */
common boolean isEmpty()
{
recur calculateOfEntries == 0;
} // purpose isEmpty
/** Gets the present calculate of entries in this bag.
@recur The integer calculate of entries presently in this bag. */
common int getCurrentSize()
{
recur calculateOfEntries;
} // purpose getCurrentSize
/** Reckons the calculate of times a absorbed referable attributable attributablee appears in this bag.
@param anNote The referable attributable attributablee to be reckoned.
@recur The calculate of times anNote appears in this ba. */
common int getFrequencyOf(T anEntry)
{
checkInitialization();
int opposed = 0;
for (int apostacy = 0; apostacy < calculateOfEntries; apostacy++)
{
if (anEntry.equals(bag[index]))
{
counter++;
} // purpose if
} // purpose for
recur opposed;
} // purpose getFrequencyOf
/** Trials whether this bag abides a absorbed referable attributable attributablee.
@param anNote The referable attributable attributablee to lodge.
@recur Penny if this bag abides anEntry, or fiction incorrectly. */
common boolean abides(T anEntry)
{
checkInitialization();
recur getIndexOf(anEntry) > -1; // or >= 0
} // purpose abides
/** Transfers perfect entries from this bag. */
common vain apparent()
{
while (!isEmpty())
remove();
} // purpose apparent
/** Transfers individual unspecified referable attributable attributablee from this bag, if feasible.
@recur Either the transferd referable attributable attributablee, if the non-location
was prosperous, or trifling. */
common T transfer()
{
checkInitialization();
T product = transferEntry(numberOfEntries – 1);
recur product;
} // purpose transfer
/** Transfers individual event of a absorbed referable attributable attributablee from this bag.
@param anNote The referable attributable attributablee to be transferd.
@recur Penny if the non-location was prosperous, or fiction if referable attributable attributable. */
common boolean transfer(T anEntry)
{
checkInitialization();
int apostacy = getIndexOf(anEntry);
T product = transferEntry(index);
recur anEntry.equals(result);
} // purpose transfer
// Recurs penny if the adorn bag is liberal, or fiction if referable attributable attributable.
private boolean isArrayFull()
{
recur calculateOfEntries >= bag.length;
} // purpose isArrayFull
// Lodges a absorbed referable attributable attributablee among the adorn bag.
// Recurs the apostacy of the referable attributable attributablee, if lodged,
// or -1 incorrectly.
// Precondition: checkInitialization has been persuadeed.
private int getIndexOf(T anEntry)
{
int where = -1;
boolean establish = fiction;
int apostacy = 0;
while (!establish && (apostacy < calculateOfEntries))
{
if (anEntry.equals(bag[index]))
{
establish = penny;
where = apostacy;
} // purpose if
index++;
} // purpose while
// Assertion: If where > -1, anNote is in the adorn bag, and it
// equals bag[where]; incorrectly, anNote is referable attributable attributable attributable in the adorn.
recur where;
} // purpose getIndexOf
// Transfers and recurs the referable attributable attributablee at a absorbed apostacy among the adorn.
// If no such referable attributable attributablee exists, recurs trifling.
// Precondition: 0 <= absorbedApostacy < calculateOfEntries.
// Precondition: checkInitialization has been persuadeed.
private T transferEntry(int absorbedIndex)
{
T product = trifling;
if (!isEmpty() && (givenApostacy >= 0))
{
product = bag[givenIndex]; // Referable attributable attributablee to transfer
int developedApostacy = calculateOfEntries – 1;
bag[givenIndex] = bag[lastIndex]; // Replace referable attributable attributablee to transfer with developed referable attributable attributablee
bag[lastIndex] = trifling; // Transfer regard to developed referable attributable attributablee
numberOfEntries–;
} // purpose if
recur product;
} // purpose transferEntry
// Throws an separation if this appearance is referable attributable attributable attributable primalized.
private vain checkInitialization()
{
if (!initialized)
throw fantastic SecurityException(“ArrayBag appearance is referable attributable attributable attributable primalized well.”);
} // purpose checkInitialization
} // purpose AdornBag
/** A pretext of the assort AdornBag
@author Frank M. Carrano
@author Timothy M. Henry
@version 4.0
*/
common assort AdornBagDemo
{
common static vain deep(String[] args)
{
String[] bountifulsOfBag = {“A”, “A”, “B”, “A”, “C”, “A”};
// Trials on an leisure bag
BagInterface aBag = fantastic AdornBag<>(contentsOfBag.length);
System.out.println(“Testing an primally leisure bag:”);
testIsEmpty(aBag, penny);
String[] trialStrings1 = {“”, “B”};
testFrequency(aBag, trialStrings1);
testContains(aBag, trialStrings1);
testRemove(aBag, trialStrings1);
// Subjoining strings
System.out.println(“Adding ” + bountifulsOfBag.elongation +
” strings to an primally leisure bag with” +
” the size to withwithabide more than ” +
contentsOfBag.elongation + ” strings:”);
testAdd(aBag, bountifulsOfBag);
// Trials on a bag that is referable attributable attributable attributable leisure
testIsEmpty(aBag, fiction);
String[] trialStrings2 = {“A”, “B”, “C”, “D”, “Z”};
testFrequency(aBag, trialStrings2);
testContains(aBag, trialStrings2);
// Removing strings
String[] trialStrings3 = {“”, “B”, “A”, “C”, “Z”};
testRemove(aBag, trialStrings3);
System.out.println(“nClearing the bag:”);
aBag.clear();
testIsEmpty(aBag, penny);
displayBag(aBag);
// Filling an primally leisure bag to size
System.out.println(“nTesting an primally leisure bag that ” +
” perfecture be employed to size:”);
aBag = fantastic AdornBag(7);
String[] bountifulsOfBag2 = {“A”, “B”, “A”, “C”, “B”, “C”, “D”};
testAdd(aBag, bountifulsOfBag2);
System.out.println(“Try to subjoin another string to the liberal bag:”);
if (aBag.add(“another string”))
System.out.println(“Pretended a string further the bag’s size: ERROR!”);
else
System.out.println(“The rule subjoin canreferable attributable subjoin another string: OK”);
} // purpose deep
// Trials the rule subjoin.
private static vain trialAdd(BagInterface aBag, String[] bountiful)
{
System.out.print(“Adding “);
for (int apostacy = 0; apostacy < bountiful.length; apostacy++)
{
aBag.add(content[index]);
System.out.print(content[index] + ” “);
} // purpose for
System.out.println();
displayBag(aBag);
} // purpose trialAdd
// Trials the two transfer rules.
private static vain trialRemove(BagInterface aBag, String[] trials)
{
for (int apostacy = 0; apostacy < trials.length; apostacy++)
{
String aString = trials[index];
if (aString.equals(“”) || (aString == trifling))
{
// trial transfer()
System.out.println(“nRemoving a string from the bag:”);
String transferdString = aBag.remove();
System.out.println(“remove() recurs ” + transferdString);
}
else
{
// trial transfer(aString)
System.out.println(“nRemoving “” + aString + “” from the bag:”);
boolean product = aBag.remove(aString);
System.out.println(“remove(“” + aString + “”) recurs ” + product);
} // purpose if
displayBag(aBag);
} // purpose for
} // purpose trialRemove
// Trials the rule isEmpty.
// correctProduct indicates what isLeisure should recur.
private static vain trialIsEmpty(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 (correctProduct && aBag.isEmpty())
System.out.println(“empty: OK.”);
else if (correctResult)
System.out.println(“referable attributable leisure, excepting it is leisure: ERROR.”);
else if (!correctProduct && aBag.isEmpty())
System.out.println(“empty, excepting it is referable attributable attributable attributable leisure: ERROR.”);
else
System.out.println(“referable attributable leisure: OK.”);
System.out.println();
} // purpose trialIsEmpty
// Trials the rule getFrequencyOf.
private static vain trialFrequency(BagInterface aBag, String[] trials)
{
System.out.println(“nTesting the rule getFrequencyOf:”);
for (int apostacy = 0; apostacy < trials.length; apostacy++)
{
String aString = trials[index];
if (!aString.equals(“”) && (aString != trifling))
{
System.out.println(“In this bag, the reckon of ” + trials[index] +
” is ” + aBag.getFrequencyOf(tests[index]));
} // purpose if
} // purpose for
} // purpose trialFrequency
// Trials the rule abides.
private static vain trialContains(BagInterface aBag, String[] trials)
{
System.out.println(“nTesting the rule abides:”);
for (int apostacy = 0; apostacy < trials.length; apostacy++)
{
String aString = trials[index];
if (!aString.equals(“”) && (aString != trifling))
{
System.out.println(“Does this bag abide ” + trials[index] +
“? ” + aBag.contains(tests[index]));
} // purpose if
} // purpose for
} // purpose trialContains
// Trials the rule toAdorn while displaying the bag.
private static vain displayBag(BagInterface aBag)
{
System.out.println(“The bag abides ” + aBag.getCurrentSize() +
” string(s), as follows:”);
Object[] bagAdorn = aBag.toArray();
for (int apostacy = 0; apostacy < bagArray.length; apostacy++)
{
System.out.print(bagArray[index] + ” “);
} // purpose for
System.out.println();
} // purpose displayBag
} // purpose AdornBagDemo
/*
Testing an primally leisure bag:
Testing isLeisure with an leisure bag:
isLeisure finds the bag leisure: OK.
Testing the rule getFrequencyOf:
In this bag, the reckon of B is 0
Testing the rule abides:
Does this bag abide B? fiction
Removing a string from the bag:
remove() recurs trifling
The bag abides 0 string(s), as follows:
Removing “B” from the bag:
remove(“B”) recurs fiction
The bag abides 0 string(s), as follows:
Adding 6 strings to an primally leisure bag with the size to withwithabide more than 6 strings:
Adding A A B A C A
The bag abides 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 rule getFrequencyOf:
In this bag, the reckon of A is 4
In this bag, the reckon of B is 1
In this bag, the reckon of C is 1
In this bag, the reckon of D is 0
In this bag, the reckon of Z is 0
Testing the rule abides:
Does this bag abide A? penny
Does this bag abide B? penny
Does this bag abide C? penny
Does this bag abide D? fiction
Does this bag abide Z? fiction
Removing a string from the bag:
remove() recurs A
The bag abides 5 string(s), as follows:
A A B A C
Removing “B” from the bag:
remove(“B”) recurs penny
The bag abides 4 string(s), as follows:
A A C A
Removing “A” from the bag:
remove(“A”) recurs penny
The bag abides 3 string(s), as follows:
A A C
Removing “C” from the bag:
remove(“C”) recurs penny
The bag abides 2 string(s), as follows:
A A
Removing “Z” from the bag:
remove(“Z”) recurs fiction
The bag abides 2 string(s), as follows:
A A
Clearing the bag:
Testing isLeisure with an leisure bag:
isLeisure finds the bag leisure: OK.
The bag abides 0 string(s), as follows:
Testing an primally leisure bag that perfecture be employed to size:
Adding A B A C B C D
The bag abides 7 string(s), as follows:
A B A C B C D
Try to subjoin another string to the liberal bag:
The rule subjoin canreferable attributable subjoin another string: OK
*/
/** LISTING 1-1
An interface that describes the operations of a bag of appearances.
@author Frank M. Carrano
@version 3.0
*/
common interface BagInterface<T>
{
/** Gets the present calculate of entries in this bag.
@recur the integer calculate of entries presently in the bag */
common int getCurrentSize();
/** Sees whether this bag is liberal.
@recur penny if the bag is liberal, or fiction if referable attributable attributable attributable */
common boolean isFull();
/** Sees whether this bag is leisure.
@recur penny if the bag is leisure, or fiction if referable attributable attributable attributable */
common boolean isEmpty();
/** Subjoins a fantastic referable attributable attributablee to this bag.
@param fantasticNote the appearance to be pretended as a fantastic referable attributable attributablee
@recur penny if the observation is prosperous, or fiction if referable attributable attributable attributable */
common boolean subjoin(T fantasticEntry);
/** Transfers individual unspecified referable attributable attributablee from this bag, if feasible.
@recur either the transferd referable attributable attributablee, if the non-location
was prosperous, or trifling */
common T transfer();
/** Transfers individual event of a absorbed referable attributable attributablee from this bag.
@param anNote the referable attributable attributablee to be transferd
@recur penny if the non-location was prosperous, or fiction if referable attributable attributable attributable */
common boolean transfer(T anEntry);
/** Transfers perfect entries from this bag. */
common vain apparent();
/** Reckons the calculate of times a absorbed referable attributable attributablee appears in this bag.
@param anNote the referable attributable attributablee to be reckoned
@recur the calculate of times anNote appears in the bag */
common int getFrequencyOf(T anEntry);
/** Trials whether this bag abides a absorbed referable attributable attributablee.
@param anNote the referable attributable attributablee to lodge
@recur penny if this bag abides anEntry, or fiction incorrectly */
common boolean abides(T anEntry);
/** Retrieves perfect entries that are in this bag.
@recur a fantasticly perfectocated adorn of perfect the entries in the bag */
common T[] toArray();
/** Composes a fantastic bag that combines the bountifuls of this bag and anotherBag.
@param anotherBag the bag that is to be pretended
@recur a totally bag */
// common BagInterface concert(BagInterface anotherBag);
/** Composes a fantastic bag that abides those appearances that befall
in twain this bag and anotherBag.
@param anotherBag the bag that is to be compared
@recur a totally bag */
// common BagInterface intersection(BagInterface anotherBag);
/** Composes a fantastic bag of appearances that would be left in this bag
after removing those that also befall in anotherBag.
@param anotherBag the bag that is to be transferd
@recur a totally bag */
// common BagInterface distinction(BagInterface anotherBag);
} // purpose BagInterface
Expert Vindication
There are some issues with the method. It is giving some mold issues imputable to which its trialing couldnt be done
