The following is what I am supposed to add.

---------------------------------------------------------------------------------------------

6. Implement and test a new method boolean splitInto(BagInterface first, BagInterface second){ ... } which will split and add the contents of the bag into two bags that are passed in as arguments. If there are an odd number of items, put the extra item into the first bag. The method will return a boolean value. If either bag overflows, return false. Otherwise, return true. Note that while you will directly access the array of the bag that the method is applied to, you can only use the methods from BagInterface on the arguments.

7. Implement and test a new method boolean addAll(BagInterface toAdd){ ... } which will add all of the items from the argument into the bag. The method will return a boolean value indicating an overflow. If adding the items would cause the bag to overflow, do nothing and return false. Otherwise, add the items and return true. Note that while you will directly access the array of the bag that the method is applied to, you can only use the methods from BagInterface on the argument.

8. Implement and test a new method boolean isSet(){ ... } which will return true if the bag is also a set (has no duplicates).

9. Implement and test a new method T getMode(){ ... } which will return the item with the greatest frequency. If there isnt a single item with the greatest frequency, return null.

The following is what I have done so far.

--------------------------------------------------------------------------------------------

ArrayBag.java

--------------------------------------------------------------------------------------------

/** A class of bags whose entries are stored in a fixed-size array. @author Frank M. Carrano * This code is from Chapter 2 of * Data Structures and Abstractions with Java 4/e * by Carrano * * The toString method is overwritten to give a nice display of the items in * the bag in this format Bag{Size:# [1] [2] [3] [4] } * //- * @version 4.0 */

public final class ArrayBag implements BagInterface {

private final T[] bag; private int numberOfEntries; private static final int DEFAULT_CAPACITY = 25;

private boolean initialized = false; 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 initial 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

/** Throws an exception if this object is not initialized. * */ private void checkInitialization() { if (!initialized) throw new SecurityException("ArrayBag object is not initialized " + "properly."); }

/** Retrieves all entries that are in this bag. @return A newly allocated array of all the entries in the 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 for (int index = 0; index < numberOfEntries; index++) { result[index] = bag[index]; } // end for return result; } // end toArray

/** Sees whether this bag is full. @return True if the bag is full, or false if not. */ private boolean isArrayFull() { return numberOfEntries >= bag.length; } // end isArrayFull

/** Sees whether this bag is empty. @return True if the 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 the 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 the bag. */ 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 the bag contains anEntry, or false if not. */ public boolean contains(T anEntry) { checkInitialization(); return getIndexOf(anEntry) > -1; } // 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 if otherwise. */ public T remove() { checkInitialization();

// MODIFY THIS METHOD TO REMOVE A RANDOM ITEM FROM THE BAG 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

// Removes and returns the entry at a given array index within the array bag. // If no such entry exists, returns null. // Preconditions: 0 <= givenIndex < numberOfEntries; // checkInitialization has been called. private T removeEntry(int givenIndex) { T result = null; if (!isEmpty() && (givenIndex >= 0)) { result = bag[givenIndex]; // entry to remove bag[givenIndex] = bag[numberOfEntries - 1]; // Replace entry with last entry bag[numberOfEntries - 1] = null; // remove last entry numberOfEntries--; } // end if return result; } // end removeEntry

// 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 stillLooking = true; int index = 0; while ( stillLooking && (index < numberOfEntries)) { if (anEntry.equals(bag[index])) { stillLooking = false; where = index; } // end if index++; } // end for // 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

/** Override the equals method so that we can tell if two bags contain the same items * the contents in the bag. * @return a string representation of the contents of the bag */ public String toString() {

String result = "Bag{Size:" + numberOfEntries + " ";

for (int index = 0; index < numberOfEntries; index++) { result += "[" + bag[index] + "] "; } // end for

result += "}"; return result; } // end toArray

/********************************************************************* * * METHODS TO BE COMPLETED * * ************************************************************************/

/** Check to see if two bags are equals. * @param aBag Another object to check this bag against. * @return True the two bags contain the same objects with the same frequencies. */ public boolean equals(ArrayBag aBag) { boolean result = true; // result of comparison of bags

// COMPLETE THIS METHOD

if (getCurrentSize() == aBag.getCurrentSize()) { for (int pos = 0; pos < getCurrentSize(); pos++) { /*int countInThisBag = getFrequencyOf(bag[pos]); int countInThatBag = aBag.getFrequencyOf(bag[pos]); if (countInThisBag != countInThatBag); */ if (getFrequencyOf(bag[pos]) != aBag.getFrequencyOf(bag[pos])) { result = false; } } }

else { result = false; }

return result; } // end equals

/** Duplicate all the items in a bag. * @return True if the duplication is possible. */ public boolean duplicateAll() { checkInitialization(); boolean success = true; //

// COMPLETE THIS METHOD

int countInBag = getCurrentSize();

if (countInBag * 2 <= bag.length) { for (int pos = 0; pos < countInBag; pos++) { add(bag[pos]); } }

else { success = false; }

return success; } // end duplicateAll

/** Remove all duplicate items from a bag */ public void removeDuplicates() { checkInitialization();

// COMPLETE THIS METHOD

for (int pos = 0; pos < getCurrentSize(); pos++) { while (getFrequencyOf(bag[pos]) > 1) { remove(bag[pos]); } }

return; } // end removeDuplicates

} // end ArrayBag

BagInterface.java

---------------------------------------------------------------------------------------

/** An interface that describes the operations of a bag of objects. @author Frank M. Carrano * This code is from Chapter 1 of * Data Structures and Abstractions with Java 4/e * by Carrano */ public interface BagInterface {

/** 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, if possible. @param anEntry The entry to be removed. @return True if the removal was successful, or false if not */ public boolean remove(T anEntry);

/** Removes all entries from this bag. */ public void clear();

/** Counts the number of times a given entry appears in this bag. @param anEntry The entry to be counted. @return The number of times anEntry appears in the bag. */ public int getFrequencyOf(T anEntry);

/** Tests whether this bag contains a given entry. @param anEntry The entry to locate. @return True if the bag contains anEntry, or false if not. */ public boolean contains(T anEntry);

/** Retrieves all entries that are in this bag. @return A newly allocated array of all the entries in the bag. Note: If the bag is empty, the returned array is empty. */ public T[] toArray(); } // end BagInterface