ArrayList removeFirst method

[heavyone]

I am trying to write a removeFirst method for an ArrayList of the generic type. The removeFirst method is supposed to do a few things: 1) If the list is empty it throws an error. 2) It stores the data in a node pointed to by head. 3) Set the head to head's next. 4) decrement the size. 5) returns the data. I can do 1,4, and 5 but I am stuck on 2 and 3. Here is the code I have so far. Please take a look and give me a hint or suggestion:
=============== =============== =============== ============
public class ArrayList<T> implements ListADT<T>
{
protected final int DEFAULT_CAPACIT Y = 100;
private final int NOT_FOUND = -1;
protected int rear;
protected T[] list;


//-----------------------------------------------------------------
// Creates an empty list using the default capacity.
//-----------------------------------------------------------------
public ArrayList()
{
rear = 0;
list = (T[])(new Object[DEFAULT_CAPACIT Y]);
}

//-----------------------------------------------------------------
// Creates an empty list using the specified capacity.
//-----------------------------------------------------------------
public ArrayList (int initialCapacity )
{
rear = 0;
list = (T[])(new Object[initialCapacity]);
}

//-----------------------------------------------------------------
// Removes and returns the first element in the list.
//-----------------------------------------------------------------

public T removeFirst()th rows EmptyCollection Exception
{
if (rear == 0)
throw new EmptyCollection Exception("Tryi ng to remove first element");


return result;

}
//-----------------------------------------------------------------
// Removes and returns the specified element.
//-----------------------------------------------------------------
public T remove (T element)
{
T result;
int index = find (element);

if (index == NOT_FOUND)
throw new ElementNotFound Exception ("list");

result = list[index];
rear--;
// shift the appropriate elements
for (int scan=index; scan < rear; scan++)
list[scan] = list[scan+1];


list[rear] = null;

return result;
}


//-----------------------------------------------------------------
// Returns a reference to the element at the front of the list.
// The element is not removed from the list. Throws an
// EmptyCollection Exception if the list is empty.
//-----------------------------------------------------------------
public T first() throws EmptyCollection Exception
{ return result;
}

//-----------------------------------------------------------------
// Returns a reference to the element at the rear of the list.
// The element is not removed from the list. Throws an
// EmptyCollection Exception if the list is empty.
//-----------------------------------------------------------------
public T last() throws EmptyCollection Exception
{ return result;
}

//-----------------------------------------------------------------
// Returns true if this list contains the specified element.
//-----------------------------------------------------------------
public boolean contains (T target)
{
return (find(target) != NOT_FOUND);
}

//-----------------------------------------------------------------
// Returns the array index of the specified element, or the
// constant NOT_FOUND if it is not found.
//-----------------------------------------------------------------
private int find (T target)
{
int scan = 0, result = NOT_FOUND;
boolean found = false;

if (! isEmpty())
while (! found && scan < rear)
if (target.equals( list[scan]))
found = true;
else
scan++;

if (found)
result = scan;

return result;
}

//-----------------------------------------------------------------
// Returns true if this list is empty and false otherwise.
//-----------------------------------------------------------------
public boolean isEmpty()
{
return (rear==0);
}

//-----------------------------------------------------------------
// Returns the number of elements currently in this list.
//-----------------------------------------------------------------
public int size()
{
return rear;
}

//-----------------------------------------------------------------
// Returns an iterator for the elements currently in this list.
//-----------------------------------------------------------------
public Iterator<T> iterator()
{
return new ArrayIterator<T > (list, rear);
}

//-----------------------------------------------------------------
// Returns a string representation of this list.
//-----------------------------------------------------------------
public String toString()
{
String result = " ";

for (int index = 0; index < rear; index++)
result = result + list[index].toString() + "\n";

return result;
}

//-----------------------------------------------------------------
// Creates a new array to store the contents of the list with
// twice the capacity of the old one.
//-----------------------------------------------------------------
protected void expandCapacity( )
{
T[] larger = (T[])(new Object[list.length*2]);

for (int scan=0; scan < list.length; scan++)
larger[scan] = list[scan];

list = larger;
}
}

[DeMan]

It appears you are implementing the whole type?

While implementing it with an array will work, can I suggest that you try to use an actual linked list. Java is reasonably simple for this, and you will find that insert and remove methods will be more efficient...
Unless you are required to use an array for this , I would try to avoid it....

[heavyone]

The 2nd part of the project is to do the same methods with a LinkedList in mind so that we can see the time variance between the two with a sample driver class that the teacher has produced. My problem right now is that I am lost on writing the removeFirst method.

[DeMan]

Inefficient I know....

Since you are using arrays, you know that this element is in list[0], and we don't really even have to delete him, we can copy list[1] over him, list[2] over list[1] ETC...

Pseudocode (probably more javanese than anything)

for(i=0 to list.size-1) //or length 
{
  list[i]=list[i+1]
}
list[list.size] = NULL; //or zero or whatever you need to do to delete
 

[heavyone]

This is what I came up with on my own, tell me what you think.
=============== =============== =============== =========

public T removeFirst()th rows EmptyCollection Exception
{
T result;
if (rear == 0)
throw new EmptyCollection Exception("Tryi ng to remove first element");
result = list[rear];
rear --;

return result;

}

[DeMan]

Depending on how you implement your list (like if you stored the first element at the bac) that would work. Can I just clarify that we ARE trying to create a list structure? Because I sus[ect you're trying to create a stack......

Also, since I'm being Pinickity (??) can I suggest that you enclose your code in code tags for easier reading (by using the # button above).

[heavyone]

Sorry about the long code I displayed. Anyway, I figured it all out, but thanks for the help.

[r035198x]

Sorry about the long code I displayed. Anyway, I figured it all out, but thanks for the help.

Posting long code is not a problem as long as you enclose it in code tags.