Circular Buffer

From:http://bradforj287.blogspot.com/2010/11/efficient-circular-buffer-in-java.html

 import java.util.NoSuchElementException;
  /**
   * Thread safe fixed size circular buffer implementation. Backed by an array.
   *
   * @author brad
   */
  public class ArrayCircularBuffer<T> {
       // internal data storage
       private T[] data;
       // indices for inserting and removing from queue
       private int front = ;
       private int insertLocation = ;
       // number of elements in queue
       private int size = ;
       /**
        * Creates a circular buffer with the specified size.
        *
        * @param bufferSize
        *      - the maximum size of the buffer
        */
       public ArrayCircularBuffer(int bufferSize) {
            data = (T[]) new Object[bufferSize];
       }
       /**
        * Inserts an item at the end of the queue. If the queue is full, the oldest
        * value will be removed and head of the queue will become the second oldest
        * value.
        *
        * @param item
        *      - the item to be inserted
        */
       public synchronized void insert(T item) {
            data[insertLocation] = item;
            insertLocation = (insertLocation + ) % data.length;
            /**
             * If the queue is full, this means we just overwrote the front of the
             * queue. So increment the front location.
             */
            if (size == data.length) {
                 front = (front + ) % data.length;
            } else {
                 size++;
            }
       }
       /**
        * Returns the number of elements in the buffer
        *
        * @return int - the number of elements inside this buffer
        */
       public synchronized int size() {
            return size;
       }
       /**
        * Returns the head element of the queue.
        *
        * @return T
        */
       public synchronized T removeFront() {
            if (size == ) {
                 throw new NoSuchElementException();
            }
            T retValue = data[front];
            front = (front + ) % data.length;
            size--;
            return retValue;
       }
       /**
        * Returns the head of the queue but does not remove it.
        *
        * @return
        */
       public synchronized T peekFront() {
            if (size == ) {
                 return null;
            } else {
                 return data[front];
            }
       }
       /**
        * Returns the last element of the queue but does not remove it.
        *
        * @return T - the most recently added value
        */
       public synchronized T peekLast() {
            if (size == ) {
                 return null;
            } else {
                 int lastElement = insertLocation - ;
                 if (lastElement < ) {
                      lastElement = data.length - ;
                 }
                 return data[lastElement];
            }
       }
  }