public UnboundedFifoBuffer() 
{
                                 
        this(32);
}

Constructs an UnboundedFifoBuffer with the default number of elements. It is exactly the same as performing the following:

new UnboundedFifoBuffer(32);

 public UnboundedFifoBuffer(int initialSize) 
{
        if (initialSize < = 0) {
            throw new IllegalArgumentException("The size must be greater than 0");
        }
        buffer = new Object[initialSize + 1];
        head = 0;
        tail = 0;
}

Constructs an UnboundedFifoBuffer with the specified number of elements. The integer must be a positive integer.

Parameters:

initialSize - the initial size of the buffer

Throws:

IllegalArgumentException - if the size is less than 1

 public boolean add(Object obj) 
{
        if (obj == null) {
            throw new NullPointerException("Attempted to add null object to buffer");
        }
        if (size() + 1  >= buffer.length) {
            // copy contents to a new buffer array
            Object[] tmp = new Object[((buffer.length - 1) * 2) + 1];
            int j = 0;
            // move head to element zero in the new array
            for (int i = head; i != tail;) {
                tmp[j] = buffer[i];
                buffer[i] = null;
                j++;
                i = increment(i);
            }
            buffer = tmp;
            head = 0;
            tail = j;
        }
        buffer[tail] = obj;
        tail = increment(tail);
        return true;
}

Adds the given element to this buffer.

 public Object get() 
{
        if (isEmpty()) {
            throw new BufferUnderflowException("The buffer is already empty");
        }
        return buffer[head];
}

Returns the next object in the buffer.

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

Returns true if this buffer is empty; false otherwise.

 public Iterator iterator() 
{
        return new Iterator() {
            private int index = head;
            private int lastReturnedIndex = -1;
            public boolean hasNext() {
                return index != tail;
            }
            public Object next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                lastReturnedIndex = index;
                index = increment(index);
                return buffer[lastReturnedIndex];
            }
            public void remove() {
                if (lastReturnedIndex == -1) {
                    throw new IllegalStateException();
                }
                // First element can be removed quickly
                if (lastReturnedIndex == head) {
                    UnboundedFifoBuffer.this.remove();
                    lastReturnedIndex = -1;
                    return;
                }
                // Other elements require us to shift the subsequent elements
                int i = increment(lastReturnedIndex);
                while (i != tail) {
                    buffer[decrement(i)] = buffer[i];
                    i = increment(i);
                }
                lastReturnedIndex = -1;
                tail = decrement(tail);
                buffer[tail] = null;
                index = decrement(index);
            }
        };
}

Returns an iterator over this buffer's elements.

 public Object remove() 
{
        if (isEmpty()) {
            throw new BufferUnderflowException("The buffer is already empty");
        }
        Object element = buffer[head];
        if (element != null) {
            buffer[head] = null;
            head = increment(head);
        }
        return element;
}

Removes the next object from the buffer

 public int size() 
{
        int size = 0;
        if (tail <  head) {
            size = buffer.length - head + tail;
        } else {
            size = tail - head;
        }
        return size;
}

Returns the number of elements stored in the buffer.