Java tutorial
//package com.google.code.yanf4j.util; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * */ import java.io.Serializable; import java.util.AbstractList; import java.util.Arrays; import java.util.List; import java.util.NoSuchElementException; import java.util.Queue; /** * A circular queue from mina * * @author dennis * * @param <E> */ public class CircularQueue<E> extends AbstractList<E> implements List<E>, Queue<E>, Serializable { private static final long serialVersionUID = 3993421269224511264L; private static final int DEFAULT_CAPACITY = 4; private final int initialCapacity; // XXX: This volatile keyword here is a workaround for SUN Java Compiler // bug, // which produces buggy byte code. I don't event know why adding a volatile // fixes the problem. Eclipse Java Compiler seems to produce correct byte // code. private volatile Object[] items; private int mask; private int first = 0; private int last = 0; private boolean full; private int shrinkThreshold; /** * Construct a new, empty queue. */ public CircularQueue() { this(DEFAULT_CAPACITY); } public CircularQueue(int initialCapacity) { int actualCapacity = normalizeCapacity(initialCapacity); this.items = new Object[actualCapacity]; this.mask = actualCapacity - 1; this.initialCapacity = actualCapacity; this.shrinkThreshold = 0; } private static int normalizeCapacity(int initialCapacity) { int actualCapacity = 1; while (actualCapacity < initialCapacity) { actualCapacity <<= 1; if (actualCapacity < 0) { actualCapacity = 1 << 30; break; } } return actualCapacity; } /** * Returns the capacity of this queue. */ public int capacity() { return this.items.length; } @Override public void clear() { if (!isEmpty()) { Arrays.fill(this.items, null); this.first = 0; this.last = 0; this.full = false; shrinkIfNeeded(); } } @SuppressWarnings("unchecked") public E poll() { if (isEmpty()) { return null; } Object ret = this.items[this.first]; this.items[this.first] = null; decreaseSize(); if (this.first == this.last) { this.first = this.last = 0; } shrinkIfNeeded(); return (E) ret; } public boolean offer(E item) { if (item == null) { throw new NullPointerException("item"); } expandIfNeeded(); this.items[this.last] = item; increaseSize(); return true; } @SuppressWarnings("unchecked") public E peek() { if (isEmpty()) { return null; } return (E) this.items[this.first]; } @SuppressWarnings("unchecked") @Override public E get(int idx) { checkIndex(idx); return (E) this.items[getRealIndex(idx)]; } @Override public boolean isEmpty() { return (this.first == this.last) && !this.full; } @Override public int size() { if (this.full) { return capacity(); } if (this.last >= this.first) { return this.last - this.first; } else { return this.last - this.first + capacity(); } } @Override public String toString() { return "first=" + this.first + ", last=" + this.last + ", size=" + size() + ", mask = " + this.mask; } private void checkIndex(int idx) { if (idx < 0 || idx >= size()) { throw new IndexOutOfBoundsException(String.valueOf(idx)); } } private int getRealIndex(int idx) { return (this.first + idx) & this.mask; } private void increaseSize() { this.last = (this.last + 1) & this.mask; this.full = this.first == this.last; } private void decreaseSize() { this.first = (this.first + 1) & this.mask; this.full = false; } private void expandIfNeeded() { if (this.full) { // expand queue final int oldLen = this.items.length; final int newLen = oldLen << 1; Object[] tmp = new Object[newLen]; if (this.first < this.last) { System.arraycopy(this.items, this.first, tmp, 0, this.last - this.first); } else { System.arraycopy(this.items, this.first, tmp, 0, oldLen - this.first); System.arraycopy(this.items, 0, tmp, oldLen - this.first, this.last); } this.first = 0; this.last = oldLen; this.items = tmp; this.mask = tmp.length - 1; if (newLen >>> 3 > this.initialCapacity) { this.shrinkThreshold = newLen >>> 3; } } } private void shrinkIfNeeded() { int size = size(); if (size <= this.shrinkThreshold) { // shrink queue final int oldLen = this.items.length; int newLen = normalizeCapacity(size); if (size == newLen) { newLen <<= 1; } if (newLen >= oldLen) { return; } if (newLen < this.initialCapacity) { if (oldLen == this.initialCapacity) { return; } else { newLen = this.initialCapacity; } } Object[] tmp = new Object[newLen]; // Copy only when there's something to copy. if (size > 0) { if (this.first < this.last) { System.arraycopy(this.items, this.first, tmp, 0, this.last - this.first); } else { System.arraycopy(this.items, this.first, tmp, 0, oldLen - this.first); System.arraycopy(this.items, 0, tmp, oldLen - this.first, this.last); } } this.first = 0; this.last = size; this.items = tmp; this.mask = tmp.length - 1; this.shrinkThreshold = 0; } } @Override public boolean add(E o) { return offer(o); } @SuppressWarnings("unchecked") @Override public E set(int idx, E o) { checkIndex(idx); int realIdx = getRealIndex(idx); Object old = this.items[realIdx]; this.items[realIdx] = o; return (E) old; } @Override public void add(int idx, E o) { if (idx == size()) { offer(o); return; } checkIndex(idx); expandIfNeeded(); int realIdx = getRealIndex(idx); // Make a room for a new element. if (this.first < this.last) { System.arraycopy(this.items, realIdx, this.items, realIdx + 1, this.last - realIdx); } else { if (realIdx >= this.first) { System.arraycopy(this.items, 0, this.items, 1, this.last); this.items[0] = this.items[this.items.length - 1]; System.arraycopy(this.items, realIdx, this.items, realIdx + 1, this.items.length - realIdx - 1); } else { System.arraycopy(this.items, realIdx, this.items, realIdx + 1, this.last - realIdx); } } this.items[realIdx] = o; increaseSize(); } @SuppressWarnings("unchecked") @Override public E remove(int idx) { if (idx == 0) { return poll(); } checkIndex(idx); int realIdx = getRealIndex(idx); Object removed = this.items[realIdx]; // Remove a room for the removed element. if (this.first < this.last) { System.arraycopy(this.items, this.first, this.items, this.first + 1, realIdx - this.first); } else { if (realIdx >= this.first) { System.arraycopy(this.items, this.first, this.items, this.first + 1, realIdx - this.first); } else { System.arraycopy(this.items, 0, this.items, 1, realIdx); this.items[0] = this.items[this.items.length - 1]; System.arraycopy(this.items, this.first, this.items, this.first + 1, this.items.length - this.first - 1); } } this.items[this.first] = null; decreaseSize(); shrinkIfNeeded(); return (E) removed; } public E remove() { if (isEmpty()) { throw new NoSuchElementException(); } return poll(); } public E element() { if (isEmpty()) { throw new NoSuchElementException(); } return peek(); } }