Problems with List Implementation

Question

I have a list implementation that is like a linked list but contains 'n' elements in each node, set to 8 by default.
The list has a head node, and a tail node.
This is a revisit on an assignment, I'm trying to fix it.
The problem is when a number of elements have been added and then deleted from the end of the list. Then more elements are added.
I'm using a JUnit test case to test this, and what happens is about 25 elements are added and removed, but when it gets to adding a new elements after recently deleting some items towards the end of the list. My list fails because, I am unable to assign value to my tail from within my iterator.
The compiletime error I get is:
Type mismatch: cannot convert from chunklist.ChunkList<T>.Chunk<T> to chunklist.ChunkList<T>.Chunk<T>
I need to assign my tail to the previous Chunk (node), because in my iterator when I delete a Chunk the tail doesn't get automatically assigned to the previous.
Anyone know how I can get around this retarded error? or what I can do to solve my problem?
Edit: casting to Chunk<T> doesn't work either it's the same compiletime error
I have deleted all irrelevant methods and comments from this: The error is in the deleteChunk() method. I need to point tail back to the previous node there.
package chunklist;
import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class ChunkList<T> extends AbstractCollection<T>
    @SuppressWarnings({ "unchecked", "hiding" })
    private class Chunk<T>
        private T[] data;
        private Chunk<T> next;
        private int chunkSize;
        public Chunk()
            this.data = (T[])new Object[ARRAY_SIZE];
            this.next = null;
            this.chunkSize = 0;
        public boolean equalsChunk(Chunk<T> c)
            if (c == null)
                return false;
            else if (this.chunkSize != c.chunkSize)
                return false;
            else if (this.next != c.next)
                return false;
            else
                for(int i=0; i<this.chunkSize; ++i)
                    if (!(this.data.equals(c.data[i])))
return false;
return true;
}// end of Chunk<T>
@SuppressWarnings({ "hiding", "unchecked" })
private class ChunkItr<T> implements Iterator<T>
private Chunk<T> currentChunk;
private Chunk<T> previousChunk;
private Chunk<T> nextChunk;
private int currentElement;
public ChunkItr()
currentChunk = (Chunk<T>) head;
previousChunk = null;
nextChunk = (Chunk<T>) head.next;
currentElement = 0;
@Override
public boolean hasNext()
if (currentChunk == null)
return false;
else
if (currentElement < currentChunk.chunkSize)
return true;
return (currentChunk.next != null);
@Override
public T next()
if (!hasNext())
throw new NoSuchElementException();
T elementToReturn = null;
while (elementToReturn == null)
if ((currentElement == ARRAY_SIZE) ||
(currentElement == currentChunk.chunkSize))
previousChunk = currentChunk;
currentChunk = currentChunk.next;
currentElement = 0;
if (nextChunk != null)
nextChunk = currentChunk.next;
if (currentChunk.data[currentElement] != null)
elementToReturn = (T) currentChunk.data[currentElement];
++currentElement;
return elementToReturn;
@Override
public void remove()
if (currentChunk == null)
throw new IllegalStateException();
else
for (int i=currentElement-1;i<currentChunk.chunkSize;++i)
{ // shift everything down
if ( (i != 7) && (i >= 0) )
currentChunk.data[i] = currentChunk.data[i+1];
else if (i==7)
break;
currentChunk.data[currentChunk.chunkSize-1] = null;
--currentChunk.chunkSize;
--numOfElements;
--currentElement;
if (currentElement < 0)
currentElement = 0;
if (currentChunk.chunkSize <= 0)
deleteChunk();
public void deleteChunk()
if (previousChunk == null) //* @head *//
if (head.next != null)
head = head.next;
currentChunk = (Chunk<T>) head;
nextChunk = currentChunk.next;
currentElement = 0;
else currentElement=0;
else if (nextChunk == null) //* @tail *//
currentChunk = previousChunk;
currentChunk.next = null;
nextChunk = currentChunk.next;
currentElement = currentChunk.chunkSize;
tail = currentChunk; // THIS DOESN'T WORK, << ERROR HERE
else //* @middle *//
currentChunk = currentChunk.next;
previousChunk.next = currentChunk;
nextChunk = currentChunk.next;
currentElement = 0;
// back @ head? (just deleted Chunk before head)
if (currentChunk.equalsChunk((Chunk<T>) head))
previousChunk = null;
} // end ChunkItr
private static final int ARRAY_SIZE = 8;
private Chunk<T> head;
private Chunk<T> tail;
private int numOfElements;
public ChunkList()
head = null;
tail = null;
numOfElements = 0;
public void addNewChunk()
if (head == null)
head = new Chunk<T>();
tail = head;
else
tail.next = new Chunk<T>();
tail = tail.next;
@Override
public boolean add(T t)
if (t == null)
throw new IllegalArgumentException();
if (head == null)
addNewChunk();
if (tail.chunkSize == ARRAY_SIZE)
addNewChunk();
tail.data[tail.chunkSize] = t;
numOfElements++;
tail.chunkSize++;
return true;
@Override
public Iterator<T> iterator()
return new ChunkItr<T>();
@Override
public boolean remove(Object o)
// creates iterator and calls iterators remove method when it finds o.
Edited by: G-Unit on Nov 14, 2010 5:07 AM                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               

Answer 1

YoungWinston wrote:
Possibly, but I suspect you'll need to be prepared to defend your design choice with more than just test results. Why did you choose this pattern? Because it's an assignment. I will do some reading when I get around it to it. But for now I don't have time, and don't care to make time. This assignment was annoying as... So many fiddly little errors that took me too long to figure out. For now I hate Lists, I'm happy using the default ones.
1. Introduction
This document is the Project Specification for a ChunkList class to be developed by DBSD202 students this semester.
2. What you must do
The requirements specifications are detailed below:
ChunkList
In this first part of the assignment we will create a data structure called a ChunkList. The ChunkList class implements the Collection interface and >>serves a replacement for ArrayList or LinkedList. A ChunkList is like a regular linked list, except each node contains a little fixed size array of elements >>instead of just a single element. Each node also contains its own "size" int to know how full it is.
The ChunkList will have the following features...
The ChunkList object contains a head pointer to the first chunk, a tail pointer to the last chunk, and an int to track the logical size of the whole >>collection. When the size of the list is 0, the head and tail pointers are null.
Each chunk contains a fixed size T[] array, an int to track how full the chunk is, and a next pointer. The constant ARRAY_SIZE = 8; in the chunk >>class defines the fixed size of the array. Elements should be added to the array starting at its 0 index. The elements in each little array should be >>kept in a contiguous block starting at 0 (this will require shifting elements around in the little array at times). (You may want to do some testing >>with ARRAY_SIZE set to smaller values, but turn it in set to 8.)
ChunkList should be a subclass of AbstractCollection which provides some basic facilities built on top of your add(), iterator(), size() etc. primitives. >>Chunk should be an inner class defined inside of ChunkList. Only ChunkList will see or use the Chunk class directly. It's stylistically ok if ChunkList >>accesses the state (.next, .data, ...) of the Chunk objects, since Chunk essentially is just an integrated part of ChunkList. Add utility methods to >>Chunk where it helps to keep things receiver-
relative (remove for example). ChunkIterator should be a private inner class as in the lecture example.
ChunkList must support the messages: constructor, add(), size(), and iterator(). The iterator must support hasNext(), next(), and remove(). It's >>valid for the client to add "null" as an element, so you cannot use null as some sort of special marker in the array -- use your size int in each chuck. >>Make sure that size() and hasNext() are consistent about the size of the collection.
The empty collection should be implemented as null head and tail pointers. Only allocate chunks when actually needed.
The add() operation should add new elements at the end of the overall collection -- i.e. new elements should always go into the tail chunk. If the >>tail chunk is full, a new chunk should be added and become the new tail. We are not going to trouble ourselves shifting things around to use >>empty space in chunks in the middle of the list. We'll only look at the tail chunk.
Do not use a dummy node because (a) it does not help the code much, and (b) dummy nodes are lame.
Keep a single "size" variable for the whole list that stores the total number of client data elements stored in the list, so you can respond to size() in >>constant time. Similarly, keep a separate size in each chunk to know how full it is. Likewise, add(), hasNext(), next(), and remove() should all run in >>O(1) constant time (they may do computations proportional to ARRAY_SIZE, but not proportional to the overall collection length).
When using iterator.remove() to remove an element from a Chunk, overwrite the pointer to that element with a null to help the garbage >>collector. This is not a requirement, but it's a nice touch.
When an iterator.remove() operation causes a chunk to contain zero elements, that chunk should be removed from the list immediately. The code >>for deletion is quite tricky. You may store a "previous" pointer in each chunk if you wish. It is possible to code it without previous pointers by >>keeping extra pointers in the iterator to remember the two previously seen chunks during iteration. Chunk deletion will need to work for many >>boundary cases -- the first chunk, the last chunk, and so on. This is probably the trickiest part of the whole thing.
When called with correct inputs, ChunkList should return the correct result. However, when called with incorrect inputs -- e.g. iterator.remove() >>without first calling next() -- ChunkList does not need to do anything in particular. It's fine if
your code just gives the wrong output or throws a null pointer or other exception. This is a slight relaxation of the formal Collection interface which >>guarantees to throw particular exceptions for particular errors.
ChunkList Advice — Tight Code
The ChunkIterator is a tricky bit of code. There are about 4 different cases to get right, depending on if the removed chunk was first or last in the >>list. Don't have a separate copy of the remove code for each special case. If you find yourself copying and pasting code, you're doing it wrong. >>Clean up the solution so there is one copy of the remove code and then a few lines to deal with the special cases. This is just general coding style >>advice – avoid proliferating copies of the code for slightly different cases. Try to factor the code down so one copy of the code deals with many >>cases. The remove() method should be about 15 lines long.
Testing
The ChunkList is extremely well suited to unit-testing. This is good, since the ChunkList has such a large number of tricky little boundary cases >>where it can go awry. We will unit-test the ChunkList aggressively, since it's the best way to get the code right.
1. ChunkList Basic Testing
To get started, write some basic unit tests that build up a ChunkList of Strings with add(), and then iterate over it and remove a few elements, >>checking that the list look right before and after the removes. These tests will get the most basic add()/iterator()/remove() code working.
2. ChunkList Super Test
I will provide code for an extremely aggressive test on the ChunkList. Only try this after your basic tests are working. Because the ArrayList (known >>to be correct) and the ChunkList both implement the Collection interface, we can use a unit-test strategy where we do the same operation on >>both an ArrayList and ChunkList, and then verify that they get the same output after each operation.
The SuperTest creates both an ArrayList and a ChunkList. We'll call an "operation" either a single addition or an iteration down the collection doing >>a few random removes. Do the same random operation to both the ArrayList and ChunkList, and then check that the two look the same, element >>by element. Then loop around and do that 4999 more times, checking the two again after each random operation. We want to push on the >>ChunkList
to get every weird combination of list length and this or that chunk being full or empty at the time of add or series of removes in some position.
When you get it take a look at the SuperTest code. It creates a Random(1) for its random number generation, object passing 1 as the seed. In >>this way, the series of "random" operations is the same every time the test is run.
3. ChunkList SpeedTest
The unit-tests should work on the correctness of the ChunkList, and that's the most important thing. Look at the source of the provided >>ChunkSpeed class and try running it. It runs a timing test on the ArrayList, LinkedList, and ChunkList classes. The test is a crude simulation of >>collection add/remove/iterate use. ChunkSpeed prints the milliseconds required to do the following representative mix of operations...
- Use add() to build a 50,000 element collection
- Create an iterator to iterate halfway through the collection
- Use the iterator to remove 10,000 elements at that point
- Creates and runs iterators to run over the whole collection 5 times
The speeds seen depend on many factors, including the ARRAY_SIZE, the specific hardware, the system load, JVM version, etc., and some runs >>will be way off because the GC thread runs during part of the test. Broadly speaking, on average the ChunkList should be roughly as fast or faster >>than the LinkedList, and a lot faster (a factor of 10 or so) than the ArrayList. The speed numbers have a lot of noise in them, so don't worry about >>a single run. The ChunkList might be slower than the LinkedList on occasion. However, if your ChunkList is consistently slower than the Linked List >>or ArrayList, there is probably something wrong with your ChunkList algorithm -- some operation that is supposed to be O(1) is O(n). The most >>important methods to be fast are hasNext() and next(), since they are the most commonly called by the client.Edited by: G-Unit on Nov 15, 2010 7:31 AM
Edited by: G-Unit on Nov 15, 2010 7:44 AM