remove & replace methods for java

Question

So I am having alot of difficulty conceptualizing answers for the following questions. I am not looking for answers but rather useful steps that I can take that will enable me to present the answers on my own. Note: to answer these questions I am given classes referenced, and a driver program. The questions are as follows:

Q.1 Implement a method replace for the ADT bag that replaces and returns any object currently in a bag with a given object.

Q.2.Write a remove method to remove every instance of an element in an ArrayBag.

Q.3. Give at least two examples of a situation where a fixed bag is appropriate and two examples of a situation where a resizable bag is appropriate.

The following code is what I have started but am not sure if I am in right direction:

a.1 public T replace(T theItem) {
    Random generator = new Random();
    int randomPosition = generator.nextInt(numberOfEntries);

    T result = null;

    if (!isEmpty() && (randomPosition >= 0)) {
        result = bag[randomPosition]; // Entry to remove
        bag[randomPosition] = theItem; // Replace entry to remove with
                                // last entry

    }
    return result;
 a.2 public void clear(T theItem) {
    while (!this.isEmpty(ArrayBag))
        this.remove();

 a.3 not sure it should be related to coding examples or something else.

Additionally, the class for the ArrayBag is below for reference:

import java.util.Arrays;
import java.util.Random;

public final class ArrayBag<T> implements  BagInterface<T> {
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 (!this.isEmpty())
        this.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

public boolean removeRandom() {
    Random generator = new Random();
    int randomPosition = generator.nextInt(numberOfEntries);
    T result = removeEntry(randomPosition);
    if (result == null) {
        return false;
    } else {
        return true;
    }

}

@Override
public boolean equals(Object obj) {
    if (obj instanceof ArrayBag) {
        ArrayBag<T> otherArrayBag = (ArrayBag<T>) obj;

        if (numberOfEntries == otherArrayBag.numberOfEntries) {

            // I create new arrays so that I can manipulate them
            // and it will not alter this.bag or otherArrayBag.bag
            T[] currentBagTempArray = toArray();
            T[] otherBagTempArray = otherArrayBag.toArray();

            Arrays.sort(currentBagTempArray);
            Arrays.sort(otherBagTempArray);

            for (int i = 0; i < numberOfEntries; i++) {
                if (!currentBagTempArray[i].equals(otherBagTempArray[i])) {
                    return false;
                }
            }
            return true;
        } else {
            return false;
        }

    } else {
        return false;
    }
}

public ResizableArrayBag<T> createResizableArray() {
    T[] currentBagContents = toArray();
    ResizableArrayBag<T> newBag = new ResizableArrayBag<T>(currentBagContents);
    return newBag;
}

// 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

Answer 1

Someone else implemented Bag using an Array at Bag Class Implementation in Java/Using Array . I only glanced at the code, so it may be a mixed Bag.

I'm assuming that Bag is like a Set, except in can store the same object more than once. You would want to implement a private collection of some sort (perhaps an Array like above). Let's call it myBag. Since you're using a generic type T, your Bag will only contain objects of type T.

For Q1, your replace() method might need to take two parameters: The object to be replaced (say findMe) and the object you're replacing it with (say replacement). If your Bag can hold duplicates, then you will probably want to replace the first object that matches. Rather than use Random(), you might need to go element by element through myBag, and replace the found element with the one you're replacing. You might want to throw an error if findMe is not found. So the method declaration might be something like:

public boolean replace(T findMe, T replacement)

and return true if findMe was found, false otherwise.

For Q2, you could create a while loop that removes the first element in myBag while the size of myBag was > 0.

For Q3, thre's no coding involved. This is a thinking question. In general, a fixed size Bag would be helpful when the size is known at the beginning will not change.

A resizable bag makes sense in more cases, where you don't know the size at the beginning and it is likely to shrink or grow, for example, a waiting list for a class.