Bag implementation as array in Java

Question

I'm supposed to implement a bag data structure (also called a multiset), an unordered collection of homogeneous values (any Java object, excluding null) that may have duplicates, for a project. I've done extensive searching on the internet but have a hard time wrapping my mind around using arrays instead of something like List and don't quite understand the syntax for using arrays in a class.

I need to implement all of java.util.Collection except as noted by throwing an UnsupportedOperationException. Yes, I HAVE to use an array and when I add to it, the capacity must increase by 10. My problem is that I'm not sure what to do about the contains method, clear method, addAll method, and a second constructor. Hopefully everything else I've added will also run smoothly. I've included the API definition in comment blocks. Any input at all would really help me.

As Mark asked below, I don't understand how to search through the bag to search for a particular element.

import java.util.Collection;
import java.util.Iterator;

class Bag<T> implements Collection<T>{
private T[] array;
public int bagSize;


public Bag(){
    array=(T[])new Object[10];
}
public Bag(Collection<T> other ){
    //Not sure what to put here
    //creates a bag containing all of the items passed to it as a Collection<T>
}

public int size() {
    return bagSize; 
}

public boolean isEmpty() {
    if(size()==0)
        return true;
    else
        return false;
}


public boolean contains(Object o) {
    //Not sure what to put here
    /*Returns true if this collection contains the specified element. More formally,
    returns true if and only if this collection contains at least one element e such 
    that (o==null ? e==null : o.equals(e)). */
    return (o.toArray()==null ? this.toArray()==null : o.toArray() == this.toArray());
    }

}


public Iterator<T> iterator() {
    throw new UnsupportedOperationException("not implemented.");
}

public Object[] toArray() {
    return array;

}

public <T> T[] toArray(T[] a) {
    throw new UnsupportedOperationException("not implemented.");
}

public boolean add(T e) {
   if(bagSize>=array.length)
       return false;
   else
   {
       ensureCapacity(bagSize+10);
       array[bagSize]=e;
       bagSize++;
       return true;
   }

}

public boolean remove(Object o) {
    for(int i=0; i<bagSize; i++)
        if(array[i].equals(o)){
            for(int j=i; j<bagSize-1; j++)
                array[j]=array[j+1];
            bagSize--;
            return true;
        }
    return false;

}

public boolean containsAll(Collection<?> c) {
    throw new UnsupportedOperationException("not implemented.");
}

public boolean addAll(Collection<? extends T> c) {
    //Not sure what to put here
    /*Adds all of the elements in the specified collection to this collection  
    (optional operation). The behavior of this operation is undefined if the specified
    collection is modified while the operation is in progress. (This implies that the
    behavior of this call is undefined if the specified collection is this collection,
    and this collection is nonempty.) */
}

public boolean removeAll(Collection<?> c) {
    throw new UnsupportedOperationException("not implemented.");
}

public boolean retainAll(Collection<?> c) {
    throw new UnsupportedOperationException("not implemented.");
}

public void clear() {
    //Not sure what to put here
    /*Removes all of the elements from this collection (optional operation). The
    collection will be empty after this call returns (unless it throws an exception).*/
}

@Override
public int hashCode(){
    throw new UnsupportedOperationException("not implemented.");
}

@Override
public boolean equals(Object e) {
    if (e == null) {
        return false;
    }
    if (getClass() != e.getClass()) {
        return false;
    }
    final Bag<T> other = (Bag<T>) e;
    return true;
}

public void ensureCapacity(int minCapacity){
    T[] biggerArray;
    if(array.length<minCapacity){
        biggerArray=(T[]) new Object[minCapacity];
        System.arraycopy(array, 0, biggerArray, 0, bagSize);
        array=biggerArray; 
    }
}

Answer 1

I'm confused about what you have inside contains... you're calling toArray() on an Object, which doesn't have a toArray() method. This suggests some fundamental misunderstanding of what you're trying to do. Despite that, you actually do seem to know how to check if the collection contains a given object, because you have to find the object in order to remove it. Your remove method returns the exact same boolean value that contains would have if called with the same object. I think you can work from that.

(Your remove method has a bug that could cause a memory leak, by the way... when it shifts the objects in the array to the left by 1, it doesn't set the array slot that is no longer included in the collection to null.)

addAll is quite simple... you're given a Collection of elements that all need to be added, and you have an add method that can add an element. These go together. (addAll is all you really need to implement your second constructor as well.)

clear is also simple. After calling it, your array needs to have no references to any objects and the size of your bag needs to be 0. Just think about how you can do that.

A working implementation of iterator() would help you quite a bit as many Collection methods (including clear) can be implemented by making use of the collection's Iterator (the convenient abstract class AbstractCollection does this), but implementing that is a bit more difficult than just implementing a basic clear that doesn't use it probably.

Also, a small note.

public boolean isEmpty() {
    if(size()==0)
        return true;
    else
        return false;
}

would be better written as:

public boolean isEmpty() {
  return size() == 0;
}

Since size() == 0 is already a boolean expression, the if/else is redundant.