Java tutorial
/* * Copyright (c) 2006-2007, Dennis M. Sosnoski. All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the * following conditions are met: * * Redistributions of source code must retain the above copyright notice, this list of conditions and the following * disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the * following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of * JiBX nor the names of its contributors may be used to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ import java.util.Iterator; /** * Hash map for counting references to <code>Object</code> keys. The map implementation is not very efficient when * resizing, but works well when the size of the map is known in advance or when accesses are substantially more common * than adds. * * @author Dennis M. Sosnoski */ public class ReferenceCountMap { /** Default fill fraction allowed before growing table. */ private static final double DEFAULT_FILL = 0.3d; /** Minimum size used for hash table. */ private static final int MINIMUM_SIZE = 63; /** Number of entries present in table. */ private int m_entryCount; /** Entries allowed before growing table. */ private int m_entryLimit; /** Size of array used for keys. */ private int m_arraySize; /** Offset added (modulo table size) to slot number on collision. */ private int m_hitOffset; /** Array of key table slots. */ private Object[] m_keyTable; /** Array of value table slots. */ private int[] m_valueTable; /** * Constructor with count. * * @param count number of values to assume in initial sizing of table */ public ReferenceCountMap(int count) { // compute initial table size (ensuring odd) m_arraySize = Math.max((int) (count / DEFAULT_FILL), MINIMUM_SIZE); m_arraySize += (m_arraySize + 1) % 2; // initialize the table information m_entryLimit = (int) (m_arraySize * DEFAULT_FILL); m_hitOffset = m_arraySize / 2; m_keyTable = new Object[m_arraySize]; m_valueTable = new int[m_arraySize]; } /** * Default constructor. */ public ReferenceCountMap() { this(0); } /** * Copy (clone) constructor. * * @param base instance being copied */ public ReferenceCountMap(ReferenceCountMap base) { // copy the basic occupancy information m_entryCount = base.m_entryCount; m_entryLimit = base.m_entryLimit; m_arraySize = base.m_arraySize; m_hitOffset = base.m_hitOffset; // copy table of items m_keyTable = new Object[m_arraySize]; System.arraycopy(base.m_keyTable, 0, m_keyTable, 0, m_arraySize); m_valueTable = new int[m_arraySize]; System.arraycopy(base.m_valueTable, 0, m_valueTable, 0, m_arraySize); } /** * Step the slot number for an entry. Adds the collision offset (modulo the table size) to the slot number. * * @param slot slot number to be stepped * @return stepped slot number */ private final int stepSlot(int slot) { return (slot + m_hitOffset) % m_arraySize; } /** * Find free slot number for entry. Starts at the slot based directly on the hashed key value. If this slot is * already occupied, it adds the collision offset (modulo the table size) to the slot number and checks that slot, * repeating until an unused slot is found. * * @param slot initial slot computed from key * @return slot at which entry was added */ private final int freeSlot(int slot) { while (m_keyTable[slot] != null) { slot = stepSlot(slot); } return slot; } /** * Standard base slot computation for a key. * * @param key key value to be computed * @return base slot for key */ private final int standardSlot(Object key) { return (key.hashCode() & Integer.MAX_VALUE) % m_arraySize; } /** * Standard find key in table. This method may be used directly for key lookup using either the * <code>hashCode()</code> method defined for the key objects or the <code>System.identityHashCode()</code> * method, and either the <code>equals()</code> method defined for the key objects or the <code>==</code> * operator, as selected by the hash technique constructor parameter. To implement a hash class based on some other * methods of hashing and/or equality testing, define a separate method in the subclass with a different name and * use that method instead. This avoids the overhead caused by overrides of a very heavily used method. * * @param key to be found in table * @return index of matching key, or <code>-index-1</code> of slot to be used for inserting key in table if not * already present (always negative) */ private int standardFind(Object key) { // find the starting point for searching table int slot = standardSlot(key); // scan through table to find target key while (m_keyTable[slot] != null) { // check if we have a match on target key if (m_keyTable[slot].equals(key)) { return slot; } else { slot = stepSlot(slot); } } return -slot - 1; } /** * Reinsert an entry into the hash map. This is used when the table is being directly modified, and does not adjust * the count present or check the table capacity. * * @param slot position of entry to be reinserted into hash map * @return <code>true</code> if the slot number used by the entry has has changed, <code>false</code> if not */ private boolean reinsert(int slot) { Object key = m_keyTable[slot]; m_keyTable[slot] = null; return assignSlot(key, m_valueTable[slot]) != slot; } /** * Internal remove pair from the table. Removes the pair from the table by setting the key entry to * <code>null</code> and adjusting the count present, then chains through the table to reinsert any other pairs * which may have collided with the removed pair. If the associated value is an object reference, it should be set * to <code>null</code> before this method is called. * * @param slot index number of pair to be removed */ private void internalRemove(int slot) { // delete pair from table m_keyTable[slot] = null; m_entryCount--; while (m_keyTable[(slot = stepSlot(slot))] != null) { // reinsert current entry in table to fill holes reinsert(slot); } } /** * Restructure the table. This is used when the table is increasing or decreasing in size, and works directly with * the old table representation arrays. It inserts pairs from the old arrays directly into the table without * adjusting the count present or checking the table size. * * @param keys array of keys * @param values array of values */ private void restructure(Object[] keys, int[] values) { for (int i = 0; i < keys.length; i++) { if (keys[i] != null) { assignSlot(keys[i], values[i]); } } } /** * Assign slot for entry. Starts at the slot found by the hashed key value. If this slot is already occupied, it * steps the slot number and checks the resulting slot, repeating until an unused slot is found. This method does * not check for duplicate keys, so it should only be used for internal reordering of the tables. * * @param key to be added to table * @param value associated value for key * @return slot at which entry was added */ private int assignSlot(Object key, int value) { int offset = freeSlot(standardSlot(key)); m_keyTable[offset] = key; m_valueTable[offset] = value; return offset; } /** * Increment a use count in the table. If the key object is already present in the table this adds one to the * reference count; if not present, this adds the key with an initial reference count of one. * * @param key referenced object (non-<code>null</code>) * @return incremented use count */ public int incrementCount(Object key) { // first validate the parameters if (key == null) { throw new IllegalArgumentException("null key not supported"); } else { // check space available int min = m_entryCount + 1; if (min > m_entryLimit) { // find the array size required int size = m_arraySize; int limit = m_entryLimit; while (limit < min) { size = size * 2 + 1; limit = (int) (size * DEFAULT_FILL); } // set parameters for new array size m_arraySize = size; m_entryLimit = limit; m_hitOffset = size / 2; // restructure for larger arrays Object[] keys = m_keyTable; m_keyTable = new Object[m_arraySize]; int[] values = m_valueTable; m_valueTable = new int[m_arraySize]; restructure(keys, values); } // find slot of table int offset = standardFind(key); if (offset >= 0) { // replace existing value for key return ++m_valueTable[offset]; } else { // add new pair to table m_entryCount++; offset = -offset - 1; m_keyTable[offset] = key; m_valueTable[offset] = 1; return 1; } } } /** * Find an entry in the table. * * @param key key for entry to be returned * @return value for key, or zero if key not found */ public final int getCount(Object key) { int slot = standardFind(key); if (slot >= 0) { return m_valueTable[slot]; } else { return 0; } } /** * Get number of entries in map. * * @return entry count */ public int size() { return m_entryCount; } /** * Get iterator for keys in map. The returned iterator is not safe, so the iterator behavior is undefined if the map * is modified. * * @return iterator */ public Iterator iterator() { return SparseArrayIterator.buildIterator(m_keyTable); } /** * Get array of keys in map. * * @return key array */ public Object[] keyArray() { Object[] keys = new Object[m_entryCount]; int fill = 0; for (int i = 0; i < m_arraySize; i++) { if (m_keyTable[i] != null) { keys[fill++] = m_keyTable[i]; } } return keys; } /** * Construct a copy of the table. * * @return shallow copy of table */ public Object clone() { return new ReferenceCountMap(this); } /** * Clear all keys and counts. */ public void clear() { for (int i = 0; i < m_keyTable.length; i++) { if (m_keyTable[i] != null) { m_keyTable[i] = null; m_valueTable[i] = 0; } } } } /* * Copyright (c) 2000-2007, Dennis M. Sosnoski. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. Redistributions in binary * form must reproduce the above copyright notice, this list of conditions and * the following disclaimer in the documentation and/or other materials provided * with the distribution. Neither the name of JiBX nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /** * Iterator class for sparse values in an array. This type of iterator * can be used for an object array which has references interspersed with * <code>null</code>s. * * @author Dennis M. Sosnoski */ class SparseArrayIterator implements Iterator { /** Empty iterator. */ public static final SparseArrayIterator EMPTY_ITERATOR = new SparseArrayIterator(new Object[0]); /** Array supplying values for iteration. */ private Object[] m_array; /** Offset of next iteration value. */ private int m_offset; /** * Internal constructor. * * @param array array containing values to be iterated */ private SparseArrayIterator(Object[] array) { m_array = array; m_offset = -1; advance(); } /** * Advance to next iteration value. This advances the current position in * the array to the next non-<code>null</code> value. * * @return <code>true</code> if element available, <code>false</code> if * not */ protected boolean advance() { while (++m_offset < m_array.length) { if (m_array[m_offset] != null) { return true; } } return false; } /** * Check for iteration element available. * * @return <code>true</code> if element available, <code>false</code> if * not */ public boolean hasNext() { return m_offset < m_array.length; } /** * Get next iteration element. * * @return next iteration element * @exception NoSuchElementException if past end of iteration */ public Object next() { if (m_offset < m_array.length) { Object result = m_array[m_offset]; advance(); return result; } else { throw new RuntimeException("No such method"); } } /** * Remove element from iteration. This optional operation is not supported * and always throws an exception. * * @exception UnsupportedOperationException for unsupported operation */ public void remove() { throw new UnsupportedOperationException(); } /** * Build iterator. * * @param array array containing values to be iterated (may be * <code>null</code>) * @return constructed iterator */ public static Iterator buildIterator(Object[] array) { if (array == null || array.length == 0) { return EMPTY_ITERATOR; } else { return new SparseArrayIterator(array); } } }