Answered Essay: Task 1: You will modify the add method in the LinkedBag class.

Task 1:

You will modify the add method in the LinkedBag class.
Add a second parameter to the method header that will be a boolean variable:

public boolean add(T newEntry, boolean sorted)

The modification to the add method will make it possible to add new entries to the beginning of the list, as it does now, but also to add new entries in sorted order. The sorted parameter if set to false will result in the existing functionality being executed (it will add the new element to the beginning of the list), if set to true the new element will be inserted into the list such that the list is in sorted order.

So for example if these are the current entries in the list: 5 -> 8 -> 10 -> 16 -> 25

And the new entry that I want to put into the list is 14, it will put it into the list between 10 and 16: 5 -> 8 -> 10 -> 14 -> 16 -> 25

Remember, this is a generic class so it needs to be able to process any kind of object, just as it does now.

Task 2:

You will need to modify the add method header in the BagInterface class also to include the new parameter.

Task 3:

Create a test program to thoroughly test the add method. Name this file LinkedBagTester.java.

Part of this assignment is to create test cases that test all possible conditions of adding data into the list to verify that the new entry will get placed into the correct place in the list. Also, you need to test the conditions of adding elements only to the beginning of the list so that you verify that your changes did not break the existing functionality.

/**

An interface that describes the operations of a bag of objects.

@author Frank M. Carrano

@author Timothy M. Henry

@version 4.1

*/

public interface BagInterface<T>

{

/**

Gets the current number of entries in this bag.

@return The integer number of entries currently in the bag.

*/

public int getCurrentSize();

/**

Sees whether this bag is empty.

@return True if the bag is empty, or false if not.

*/

public boolean isEmpty();

/**

Adds a new entry to this bag.

@param newEntry The object to be added as a new entry.

@return True if the addition is successful, or false if not.

*/

public boolean add(T newEntry);

/**

Removes one unspecified entry from this bag, if possible.

@return Either the removed entry, if the removal.

was successful, or null.

*/

public T remove();

/**

Removes one occurrence of a given entry from this bag.

@param anEntry The entry to be removed.

@return True if the removal was successful, or false if not.

*/

public boolean remove(T anEntry);

/** Removes all entries from this bag. */

public void clear();

/**

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

@param anEntry The entry to be counted.

@return The number of times anEntry appears in the bag.

*/

public int getFrequencyOf(T anEntry);

/**

Tests whether this bag contains a given entry.

@param anEntry The entry to locate.

@return True if the bag contains anEntry, or false if not.

*/

public boolean contains(T anEntry);

/**

Retrieves all entries that are in this bag.

@return A newly allocated array of all the entries in the bag.

Note: If the bag is empty, the returned array is empty.

*/

public T[] toArray();

// public <T> T[] toArray(); // Alternate

// public Object[] toArray(); // Alternate

/**

Creates a new bag that combines the contents of this bag

and anotherBag.

@param anotherBag The bag that is to be added.

@return A combined bag.

*/

// public BagInterface<T> union(BagInterface<T> anotherBag);

/**

Creates a new bag that contains those objects that occur

in both this bag and anotherBag.

@param anotherBag The bag that is to be compared.

@return A combined bag.

*/

// public BagInterface<T> intersection(BagInterface<T> anotherBag);

/**

Creates a new bag of objects that would be left in this bag

after removing those that also occur in anotherBag.

@param anotherBag The bag that is to be removed.

@return A combined bag.

*/

// public BagInterface<T> difference(BagInterface<T> anotherBag);

} // end BagInterface

/**

A class of bags whose entries are stored in a chain of linked nodes.

The bag is never full.

@author Frank M. Carrano

@author Timothy M. Henry

@version 4.1

*/

public final class LinkedBag<T> implements BagInterface<T>

{

private Node firstNode; // Reference to first node

private int numberOfEntries;

public LinkedBag()

{

firstNode = null;

numberOfEntries = 0;

} // end default constructor

/**

Sees whether this bag is empty.

@return True if this bag is empty, or false if not.

*/

public boolean isEmpty()

{

return numberOfEntries == 0;

} // end isEmpty

/**

Gets the number of entries currently in this bag.

@return The integer number of entries currently in this bag.

*/

public int getCurrentSize()

{

return numberOfEntries;

} // end getCurrentSize

/**

Adds a new entry to this bag.

@param newEntry The object to be added as a new entry

@return True if the addition is successful, or false if not.

*/

public boolean add(T newEntry) // OutOfMemoryError possible

{

// Add to beginning of chain:

Node newNode = new Node(newEntry);

newNode.next = firstNode; // Make new node reference rest of chain

// (firstNode is null if chain is empty)

firstNode = newNode; // New node is at beginning of chain

numberOfEntries++;

 

return true;

} // end add

/**

Retrieves all entries that are in this bag.

@return A newly allocated array of all the entries in this bag.

*/

public T[] toArray()

{

// The cast is safe because the new array contains null entries

@SuppressWarnings(“unchecked”)

T[] result = (T[])new Object[numberOfEntries]; // Unchecked cast

int index = 0;

Node currentNode = firstNode;

while ((index < numberOfEntries) && (currentNode != null))

{

result[index] = currentNode.data;

index++;

currentNode = currentNode.next;

} // end while

return result;

} // end toArray

/**

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

@param anEntry The entry to be counted.

@return The number of times anEntry appears in this bag.

*/

public int getFrequencyOf(T anEntry)

{

int frequency = 0;

int counter = 0;

Node currentNode = firstNode;

while ((counter < numberOfEntries) && (currentNode != null))

{

if (anEntry.equals(currentNode.data))

{

frequency++;

} // end if

counter++;

currentNode = currentNode.next;

} // end while

return frequency;

} // end getFrequencyOf

/**

Tests whether this bag contains a given entry.

@param anEntry The entry to locate.

@return True if the bag contains anEntry, or false otherwise.

*/

public boolean contains(T anEntry)

{

boolean found = false;

Node currentNode = firstNode;

 

while (!found && (currentNode != null))

{

if (anEntry.equals(currentNode.data))

found = true;

else

currentNode = currentNode.next;

} // end while

 

return found;

} // end contains

// Locates a given entry within this bag.

// Returns a reference to the node containing the entry, if located,

// or null otherwise.

private Node getReferenceTo(T anEntry)

{

boolean found = false;

Node currentNode = firstNode;

while (!found && (currentNode != null))

{

if (anEntry.equals(currentNode.data))

found = true;

else

currentNode = currentNode.next;

} // end while

return currentNode;

} // end getReferenceTo

/** Removes all entries from this bag. */

public void clear()

{

while (!isEmpty())

remove();

} // end clear

/**

Removes one unspecified entry from this bag, if possible.

@return Either the removed entry, if the removal

was successful, or null.

*/

public T remove()

{

T result = null;

if (firstNode != null)

{

result = firstNode.data;

firstNode = firstNode.next; // Remove first node from chain

numberOfEntries–;

} // end if

return result;

} // end remove

/**

Removes one occurrence of a given entry from this bag, if possible.

@param anEntry The entry to be removed.

@return True if the removal was successful, or false otherwise.

*/

public boolean remove(T anEntry)

{

boolean result = false;

Node nodeN = getReferenceTo(anEntry);

 

if (nodeN != null)

{

// Replace located entry with entry in first node

nodeN.data = firstNode.data;

firstNode = firstNode.next; // Remove first node

numberOfEntries–;

result = true;

} // end if

return result;

} // end remove

// The Node class

private class Node

{

private T data; // Entry in bag

private Node next; // Link to next node

private Node(T dataPortion)

{

this(dataPortion, null);

} // end constructor

private Node(T dataPortion, Node nextNode)

{

data = dataPortion;

next = nextNode;

} // end constructor

} // end Node

} // end LinkedBag

/** A demonstration of the class LinkedBag.

@author Frank M. Carrano

@author Timothy M. Henry

@version 4.0

*/

public class LinkedBagDemo

{

public static void main(String[] args)

{

// Tests on a bag that is empty

System.out.println(“Creating an empty bag.”);

BagInterface<String> aBag = new LinkedBag<>();

displayBag(aBag);

testIsEmpty(aBag, true);

String[] testStrings1 = {“”, “B”};

testFrequency(aBag, testStrings1);

testContains(aBag, testStrings1);

testRemove(aBag, testStrings1);

// Adding strings

String[] contentsOfBag = {“A”, “D”, “B”, “A”, “C”, “A”, “D”};

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);

} // end main

// Tests the method add.

private static void testAdd(BagInterface<String> aBag, String[] content)

{

System.out.print(“Adding to the bag: “);

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<String> 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<String> 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<String> aBag,

String[] tests)

{

System.out.println(“nTesting the method getFrequencyOf:”);

for (int index = 0; index < tests.length; index++)

System.out.println(“In this bag, the count of ” + tests[index] +

” is ” + aBag.getFrequencyOf(tests[index]));

} // end testFrequency

// Tests the method contains.

private static void testContains(BagInterface<String> aBag,

String[] tests)

{

System.out.println(“nTesting the method contains:”);

for (int index = 0; index < tests.length; index++)

System.out.println(“Does this bag contain ” + tests[index] +

“? ” + aBag.contains(tests[index]));

} // end testContains

// Tests the method toArray while displaying the bag.

private static void displayBag(BagInterface<String> 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 LinkedBagDemo

/*

Creating an empty bag.

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

Testing isEmpty with an empty bag:

isEmpty finds the bag empty: OK.

Testing the method getFrequencyOf:

In this bag, the count of is 0

In this bag, the count of B is 0

Testing the method contains:

Does this bag contain ? false

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 to the bag: A D B A C A D

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

D A C A B D 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 3

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 2

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? true

Does this bag contain Z? false

Removing a string from the bag:

remove() returns D

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

A C A B D A

Removing “B” from the bag:

remove(“B”) returns true

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

C A A D A

Removing “A” from the bag:

remove(“A”) returns true

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

C A D A

Removing “C” from the bag:

remove(“C”) returns true

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

A D A

Removing “Z” from the bag:

remove(“Z”) returns false

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

A D A

Clearing the bag:

Testing isEmpty with an empty bag:

isEmpty finds the bag empty: OK.

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

*/

Expert Answer

 

First create a package—-> package bag;

Now add all below classes:

/*********************************BagInterface.java****************************************/

package bag;

/**

* The Interface BagInterface.

*

* @param <T>

* the generic type

*/

public interface BagInterface<T> {

/**

* Gets the current number of entries in this bag.

*

* @return The integer number of entries currently in the bag.

*/

public int getCurrentSize();

/**

* Sees whether this bag is empty.

*

* @return True if the bag is empty, or false if not.

*/

public boolean isEmpty();

/**

* Adds a new entry to this bag.

*

* @param newEntry

* The object to be added as a new entry.

* @param sorted

* the sorted

* @return True if the addition is successful, or false if not.

*/

public boolean add(T newEntry, boolean sorted);

/**

* 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 tests

* The entry to locate.

* @return True if the bag contains anEntry, or false if not.

*/

public boolean contains(T tests);

/**

* Retrieves all entries that are in this bag.

*

* @return A newly allocated array of all the entries in the bag. Note: If

* the bag is empty, the returned array is empty.

*/

public T[] toArray();

// public <T> T[] toArray(); // Alternate

// public Object[] toArray(); // Alternate

/**

* Creates a new bag that combines the contents of this bag and anotherBag.

*

* @param anotherBag

* The bag that is to be added.

* @return A combined bag.

*/

// public BagInterface<T> union(BagInterface<T> anotherBag);

/**

* Creates a new bag that contains those objects that occur in both this bag

* and anotherBag.

*

* @param anotherBag

* The bag that is to be compared.

* @return A combined bag.

*/

// public BagInterface<T> intersection(BagInterface<T> anotherBag);

/**

* Creates a new bag of objects that would be left in this bag after

* removing those that also occur in anotherBag.

*

* @param anotherBag

* The bag that is to be removed.

* @return A combined bag.

*/

// public BagInterface<T> difference(BagInterface<T> anotherBag);

} // end BagInterface

/*************************************LinkedBag.java********************************/

package bag;

/**

* The Class LinkedBag.

*

* @param <T>

* the generic type

*/

public final class LinkedBag<T extends Comparable<? super T>> implements BagInterface<T> {

/** The first node. */

private Node firstNode; // Reference to first node

/** The number of entries. */

private int numberOfEntries;

/**

* Instantiates a new linked bag.

*/

public LinkedBag() {

firstNode = null;

numberOfEntries = 0;

} // end default constructor

/**

* Sees whether this bag is empty.

*

* @return True if this bag is empty, or false if not.

*/

public boolean isEmpty() {

return numberOfEntries == 0;

} // end isEmpty

/**

* Gets the number of entries currently in this bag.

*

* @return The integer number of entries currently in this bag.

*/

public int getCurrentSize() {

return numberOfEntries;

} // end getCurrentSize

/**

* Adds a new entry to this bag.

*

* @param newEntry

* The object to be added as a new entry

* @param sorted

* the sorted

* @return True if the addition is successful, or false if not.

*/

public boolean add(T newEntry, boolean sorted) // OutOfMemoryError possible

{

Node newNode = new Node(newEntry);

Node temp = firstNode;

Node first = null;

Node previous = firstNode;

if (!sorted || firstNode == null || getCurrentSize() == 1) {

// Add to beginning of chain:

newNode.next = firstNode; // Make new node reference rest of chain

// (firstNode is null if chain is empty)

firstNode = newNode; // New node is at beginning of chain

} else {

// first sort the linked list

while (temp.next != null) {

if (temp.data.compareTo(temp.next.data) > 0) {

T data = temp.data;

temp.data = temp.next.data;

temp.next.data = data;

}

temp = temp.next;

}

// add element into sorted element

first = firstNode;

while (first != null) {

if (first.data.compareTo(newNode.data) > 0) {

break;

}

previous = first;

first = first.next;

}

previous.next = newNode;

newNode.next = first;

}

numberOfEntries++;

return true;

} // end add

/**

* Retrieves all entries that are in this bag.

*

* @return A newly allocated array of all the entries in this bag.

*/

public T[] toArray() {

// The cast is safe because the new array contains null entries

@SuppressWarnings(“unchecked”)

T[] result = (T[]) new Comparable[numberOfEntries]; // Unchecked cast

int index = 0;

Node currentNode = firstNode;

while ((index < numberOfEntries) && (currentNode != null)) {

result[index] = currentNode.data;

index++;

currentNode = currentNode.next;

} // end while

return result;

} // end toArray

/**

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

*

* @param anEntry

* The entry to be counted.

* @return The number of times anEntry appears in this bag.

*/

public int getFrequencyOf(T anEntry) {

int frequency = 0;

int counter = 0;

Node currentNode = firstNode;

while ((counter < numberOfEntries) && (currentNode != null)) {

if (anEntry.equals(currentNode.data)) {

frequency++;

} // end if

counter++;

currentNode = currentNode.next;

} // end while

return frequency;

} // end getFrequencyOf

/**

* Tests whether this bag contains a given entry.

*

* @param anEntry

* The entry to locate.

* @return True if the bag contains anEntry, or false otherwise.

*/

public boolean contains(T anEntry) {

boolean found = false;

Node currentNode = firstNode;

while (!found && (currentNode != null)) {

if (anEntry.equals(currentNode.data))

found = true;

else

currentNode = currentNode.next;

} // end while

return found;

} // end contains

// Locates a given entry within this bag.

// Returns a reference to the node containing the entry, if located,

/**

* Gets the reference to.

*

* @param anEntry

* the an entry

* @return the reference to

*/

// or null otherwise.

private Node getReferenceTo(T anEntry) {

boolean found = false;

Node currentNode = firstNode;

while (!found && (currentNode != null)) {

if (anEntry.equals(currentNode.data))

found = true;

else

currentNode = currentNode.next;

} // end while

return currentNode;

} // end getReferenceTo

/** Removes all entries from this bag. */

public void clear() {

while (!isEmpty())

remove();

} // end clear

/**

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

*

* @return Either the removed entry, if the removal was successful, or null.

*/

public T remove() {

T result = null;

if (firstNode != null) {

result = firstNode.data;

firstNode = firstNode.next; // Remove first node from chain

numberOfEntries–;

} // end if

return result;

} // end remove

/**

* Removes one occurrence of a given entry from this bag, if possible.

*

* @param anEntry

* The entry to be removed.

* @return True if the removal was successful, or false otherwise.

*/

public boolean remove(T anEntry) {

boolean result = false;

Node nodeN = getReferenceTo(anEntry);

if (nodeN != null) {

// Replace located entry with entry in first node

nodeN.data = firstNode.data;

firstNode = firstNode.next; // Remove first node

numberOfEntries–;

result = true;

} // end if

return result;

} // end remove

/**

* The Class Node.

*/

// The Node class

private class Node {

/** The data. */

private T data; // Entry in bag

/** The next. */

private Node next; // Link to next node

/**

* Instantiates a new node.

*

* @param dataPortion

* the data portion

*/

private Node(T dataPortion) {

this(dataPortion, null);

} // end constructor

/**

* Instantiates a new node.

*

* @param dataPortion

* the data portion

* @param nextNode

* the next node

*/

private Node(T dataPortion, Node nextNode) {

data = dataPortion;

next = nextNode;

} // end constructor

} // end Node

} // end LinkedBag

/******************************LinkedBagDemo.java*******************************************/

package bag;

/**

* A demonstration of the class LinkedBag.

*

* @author Frank M. Carrano

* @author Timothy M. Henry

* @version 4.0

*/

public class LinkedBagDemo<T> {

@SuppressWarnings({ “rawtypes”, “unchecked” })

public static void main(String[] args) {

LinkedBagDemo obj = new LinkedBagDemo<>();

System.out.println(“******************String values Testing Report*****************”);

// Tests on a bag that is empty

System.out.println(“Creating an empty bag.”);

BagInterface<String> aBag = new LinkedBag<>();

obj.displayBag(aBag);

testIsEmpty(aBag, true);

String[] testStrings1 = { “”, “B” };

obj.testFrequency(aBag, testStrings1);

obj.testContains(aBag, testStrings1);

obj.testRemove(aBag, testStrings1);

// Adding strings

String[] contentsOfBag = { “A”, “D”, “B”, “A”, “C”, “A”, “D” };

obj.testAdd(aBag, contentsOfBag);

// Tests on a bag that is not empty

testIsEmpty(aBag, false);

String[] testStrings2 = { “A”, “B”, “C”, “D”, “Z” };

obj.testFrequency(aBag, testStrings2);

obj.testContains(aBag, testStrings2);

// Removing strings

String[] testStrings3 = { “”, “B”, “A”, “C”, “Z” };

obj.testRemove(aBag, testStrings3);

System.out.println(“nClearing the bag:”);

aBag.clear();

testIsEmpty(aBag, true);

obj.displayBag(aBag);

System.out.println(“******************Integer values Testing Report*****************”);

// Testing for Integer values

BagInterface<String> aBag1 = new LinkedBag<>();

// Adding Integer

Integer[] contentsOfBag1 = { 5, 8, 16, 10, 25, 5, 8, 14 };

obj.testAdd(aBag1, contentsOfBag1);

obj.displayBag(aBag1);

// Tests on a bag that is not empty

testIsEmpty(aBag1, false);

Integer[] testIntegers2 = { 5, 8, 30 };

obj.testFrequency(aBag1, testIntegers2);

obj.testContains(aBag1, testIntegers2);

// Removing strings

Integer[] testInteger3 = { 5, 8 };

obj.testRemove(aBag1, testInteger3);

System.out.println(“nClearing the bag1:”);

aBag1.clear();

testIsEmpty(aBag1, true);

obj.displayBag(aBag1);

} // end main

// Tests the method add.

private void testAdd(BagInterface<T> aBag, T[] content) {

// default value is sorted

boolean sorted = true;

System.out.print(“Adding to the bag: “);

for (int index = 0; index < content.length; index++) {

aBag.add(content[index], sorted);

System.out.print(content[index] + ” “);

} // end for

System.out.println();

displayBag(aBag);

} // end testAdd

// Tests the two remove methods.

private void testRemove(BagInterface<T> aBag, T[] tests) {

for (int index = 0; index < tests.length; index++) {

T aString = tests[index];

if (aString.equals(“”) || (aString == null)) {

// test remove()

System.out.println(“nRemoving a string from the bag:”);

T 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<String> 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 void testFrequency(BagInterface<T> aBag, T[] tests) {

System.out.println(“nTesting the method getFrequencyOf:”);

for (int index = 0; index < tests.length; index++) {

System.out

.println(“In this bag, the count of ” + tests[index] + ” is ” + aBag.getFrequencyOf(tests[index]));

}

} // end testFrequency

// Tests the method contains.

private void testContains(BagInterface<T> aBag, T[] tests) {

System.out.println(“nTesting the method contains:”);

for (int index = 0; index < tests.length; index++)

System.out.println(“Does this bag contain ” + tests[index] + “? ” + aBag.contains(tests[index]));

} // end testContains

// Tests the method toArray while displaying the bag.

private void displayBag(BagInterface<T> 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 LinkedBagDemo

/************************************output***********************************/

******************String values Testing Report*****************
Creating an empty bag.
The bag contains 0 string(s), as follows:

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

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

Testing the method contains:
Does this bag contain ? false
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 to the bag: A D B A C A D
The bag contains 7 string(s), as follows:
A A A B C D D
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 3
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 2
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? true
Does this bag contain Z? false

Removing a string from the bag:
remove() returns A
The bag contains 6 string(s), as follows:
A A B C D D

Removing “B” from the bag:
remove(“B”) returns true
The bag contains 5 string(s), as follows:
A A C D D

Removing “A” from the bag:
remove(“A”) returns true
The bag contains 4 string(s), as follows:
A C D D

Removing “C” from the bag:
remove(“C”) returns true
The bag contains 3 string(s), as follows:
A D D

Removing “Z” from the bag:
remove(“Z”) returns false
The bag contains 3 string(s), as follows:
A D D

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

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

******************Integer values Testing Report*****************
Adding to the bag: 5 8 16 10 25 5 8 14
The bag contains 8 string(s), as follows:
5 5 8 8 10 14 16 25
The bag contains 8 string(s), as follows:
5 5 8 8 10 14 16 25
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 5 is 2
In this bag, the count of 8 is 2
In this bag, the count of 30 is 0

Testing the method contains:
Does this bag contain 5? true
Does this bag contain 8? true
Does this bag contain 30? false

Removing “5” from the bag:
remove(“5”) returns true
The bag contains 7 string(s), as follows:
5 8 8 10 14 16 25

Removing “8” from the bag:
remove(“8”) returns true
The bag contains 6 string(s), as follows:
5 8 10 14 16 25

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

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

Buy Essay
Calculate your paper price
Pages (550 words)
Approximate price: -

Help Me Write My Essay - Reasons:

Best Online Essay Writing Service

We strive to give our customers the best online essay writing experience. We Make sure essays are submitted on time and all the instructions are followed.

Our Writers are Experienced and Professional

Our essay writing service is founded on professional writers who are on stand by to help you any time.

Free Revision Fo all Essays

Sometimes you may require our writers to add on a point to make your essay as customised as possible, we will give you unlimited times to do this. And we will do it for free.

Timely Essay(s)

We understand the frustrations that comes with late essays and our writers are extra careful to not violate this term. Our support team is always engauging our writers to help you have your essay ahead of time.

Customised Essays &100% Confidential

Our Online writing Service has zero torelance for plagiarised papers. We have plagiarism checking tool that generate plagiarism reports just to make sure you are satisfied.

24/7 Customer Support

Our agents are ready to help you around the clock. Please feel free to reach out and enquire about anything.

Try it now!

Calculate the price of your order

Total price:
$0.00

How it works?

Follow these simple steps to get your paper done

Place your order

Fill in the order form and provide all details of your assignment.

Proceed with the payment

Choose the payment system that suits you most.

Receive the final file

Once your paper is ready, we will email it to you.

HOW OUR ONLINE ESSAY WRITING SERVICE WORKS

Let us write that nagging essay.

STEP 1

Submit Your Essay/Homework Instructions

By clicking on the "PLACE ORDER" button, tell us your requires. Be precise for an accurate customised essay. You may also upload any reading materials where applicable.

STEP 2

Pick A & Writer

Our ordering form will provide you with a list of writers and their feedbacks. At step 2, its time select a writer. Our online agents are on stand by to help you just in case.

STEP 3

Editing (OUR PART)

At this stage, our editor will go through your essay and make sure your writer did meet all the instructions.

STEP 4

Receive your Paper

After Editing, your paper will be sent to you via email.