CircularArrayQueueTest.java Source code

Introduction

Here is the source code for CircularArrayQueueTest.java

Source

/*
   This program is a part of the companion code for Core Java 8th ed.
   (http://horstmann.com/corejava)
    
   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
    
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
    
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

import java.util.AbstractQueue;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Queue;

/**
 * This program demonstrates how to extend the collections framework.
 * @version 1.20 2007-05-16
 * @author Cay Horstmann
 */
public class CircularArrayQueueTest {
    public static void main(String[] args) {
        Queue<String> q = new CircularArrayQueue<String>(5);
        q.add("Amy");
        q.add("Bob");
        q.add("Carl");
        q.add("Deedee");
        q.add("Emile");
        q.remove();
        q.add("Fifi");
        q.remove();
        for (String s : q)
            System.out.println(s);
    }
}

/** 
A first-in, first-out bounded collection. 
*/
class CircularArrayQueue<E> extends AbstractQueue<E> {
    /** 
        Constructs an empty queue. 
        @param capacity the maximum capacity of the queue 
    */
    public CircularArrayQueue(int capacity) {
        elements = new Object[capacity];
        count = 0;
        head = 0;
        tail = 0;
    }

    public boolean offer(E newElement) {
        assert newElement != null;
        if (count < elements.length) {
            elements[tail] = newElement;
            tail = (tail + 1) % elements.length;
            count++;
            modcount++;
            return true;
        } else
            return false;
    }

    public E poll() {
        if (count == 0)
            return null;
        E r = peek();
        head = (head + 1) % elements.length;
        count--;
        modcount++;
        return r;
    }

    @SuppressWarnings("unchecked")
    public E peek() {
        if (count == 0)
            return null;
        return (E) elements[head];
    }

    public int size() {
        return count;
    }

    public Iterator<E> iterator() {
        return new QueueIterator();

    }

    private class QueueIterator implements Iterator<E> {
        public QueueIterator() {
            modcountAtConstruction = modcount;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            if (!hasNext())
                throw new NoSuchElementException();
            E r = (E) elements[(head + offset) % elements.length];
            offset++;
            return r;
        }

        public boolean hasNext() {
            if (modcount != modcountAtConstruction)
                throw new ConcurrentModificationException();
            return offset < count;
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

        private int offset;
        private int modcountAtConstruction;
    }

    private Object[] elements;
    private int head;
    private int tail;
    private int count;
    private int modcount;
}