Java tutorial
/* * 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.AbstractSet; import java.util.Collection; import java.util.Iterator; import java.util.Map; import java.util.NoSuchElementException; import java.util.Set; /** * A fixed size map implementation. Holds an array of keys and array of values which correspond by * index. Null key entries are available for use. This means that null is not a valid key. * * @author Jonathan Locke * @param <K> * Key type * @param <V> * Value type */ public class MiniMap<K, V> implements Map<K, V>, Serializable { private static final long serialVersionUID = 1L; /** The array of keys. Keys that are null are not used. */ private final K[] keys; /** The array of values which correspond by index with the keys array. */ private final V[] values; /** The number of valid entries */ private int size; /** The last search index. This makes putting and getting more efficient. */ private int lastSearchIndex; /** * Constructor * * @param maxEntries * The maximum number of entries this map can hold */ @SuppressWarnings("unchecked") public MiniMap(final int maxEntries) { keys = (K[]) new Object[maxEntries]; values = (V[]) new Object[maxEntries]; } /** * Constructor * * @param map * The map * @param maxEntries * The maximum number of entries this map can hold */ public MiniMap(final Map<? extends K, ? extends V> map, final int maxEntries) { this(maxEntries); putAll(map); } /** * @return True if this MicroMap is full */ public boolean isFull() { return size == keys.length; } /** * @see java.util.Map#size() */ public int size() { return size; } /** * @see java.util.Map#isEmpty() */ public boolean isEmpty() { return size == 0; } /** * @see java.util.Map#containsKey(java.lang.Object) */ public boolean containsKey(final Object key) { return findKey(0, key) != -1; } /** * @see java.util.Map#containsValue(java.lang.Object) */ public boolean containsValue(final Object value) { return findValue(0, value) != -1; } /** * @see java.util.Map#get(java.lang.Object) */ public V get(final Object key) { // Search for key final int index = findKey(key); if (index != -1) { // Return value return values[index]; } // Failed to find key return null; } /** * @see java.util.Map#put(java.lang.Object, java.lang.Object) */ public V put(final K key, final V value) { // Search for key final int index = findKey(key); if (index != -1) { // Replace existing value final V oldValue = values[index]; values[index] = value; return oldValue; } // Is there room for a new entry? if (size < keys.length) { // Store at first null index and continue searching after null index // next time final int nullIndex = nextNullKey(lastSearchIndex); lastSearchIndex = nextIndex(nullIndex); keys[nullIndex] = key; values[nullIndex] = value; size++; return null; } else { throw new IllegalStateException("Map full"); } } /** * @see java.util.Map#remove(java.lang.Object) */ public V remove(final Object key) { // Search for key final int index = findKey(key); if (index != -1) { // Store value final V oldValue = values[index]; keys[index] = null; values[index] = null; size--; return oldValue; } return null; } /** * @see java.util.Map#putAll(java.util.Map) */ public void putAll(Map<? extends K, ? extends V> map) { for (final Iterator<? extends Entry<? extends K, ? extends V>> iterator = map.entrySet() .iterator(); iterator.hasNext();) { final Map.Entry<? extends K, ? extends V> e = iterator.next(); put(e.getKey(), e.getValue()); } } /** * @see java.util.Map#clear() */ public void clear() { for (int i = 0; i < keys.length; i++) { keys[i] = null; values[i] = null; } size = 0; } /** * @see java.util.Map#keySet() */ public Set<K> keySet() { return new AbstractSet<K>() { @Override public Iterator<K> iterator() { return new Iterator<K>() { public boolean hasNext() { return i < size - 1; } public K next() { // Just in case... (WICKET-428) if (!hasNext()) { throw new NoSuchElementException(); } // Find next key i = nextKey(nextIndex(i)); // Get key return keys[i]; } public void remove() { keys[i] = null; values[i] = null; size--; } int i = -1; }; } @Override public int size() { return size; } }; } /** * @see java.util.Map#values() */ public Collection<V> values() { return new AbstractList<V>() { @Override public V get(final int index) { if (index > size - 1) { throw new IndexOutOfBoundsException(); } int keyIndex = nextKey(0); for (int i = 0; i < index; i++) { keyIndex = nextKey(keyIndex + 1); } return values[keyIndex]; } @Override public int size() { return size; } }; } /** * @see java.util.Map#entrySet() */ public Set<Entry<K, V>> entrySet() { return new AbstractSet<Entry<K, V>>() { @Override public Iterator<Entry<K, V>> iterator() { return new Iterator<Entry<K, V>>() { public boolean hasNext() { return index < size; } public Entry<K, V> next() { if (!hasNext()) { throw new NoSuchElementException(); } keyIndex = nextKey(nextIndex(keyIndex)); index++; return new Map.Entry<K, V>() { public K getKey() { return keys[keyIndex]; } public V getValue() { return values[keyIndex]; } public V setValue(final V value) { final V oldValue = values[keyIndex]; values[keyIndex] = value; return oldValue; } }; } public void remove() { keys[keyIndex] = null; values[keyIndex] = null; } int keyIndex = -1; int index = 0; }; } @Override public int size() { return size; } }; } /** * Computes the next index in the key or value array (both are the same length) * * @param index * The index * @return The next index, taking into account wraparound */ private int nextIndex(final int index) { return (index + 1) % keys.length; } /** * Finds the index of the next non-null key. If the map is empty, -1 will be returned. * * @param start * Index to start at * @return Index of next non-null key */ private int nextKey(final int start) { int i = start; do { if (keys[i] != null) { return i; } i = nextIndex(i); } while (i != start); return -1; } /** * Finds the index of the next null key. If no null key can be found, the map is full and -1 * will be returned. * * @param start * Index to start at * @return Index of next null key */ private int nextNullKey(final int start) { int i = start; do { if (keys[i] == null) { return i; } i = nextIndex(i); } while (i != start); return -1; } /** * Finds a key by starting at lastSearchIndex and searching from there. If the key is found, * lastSearchIndex is advanced so the next key search can find the next key in the array, which * is the most likely to be retrieved. * * @param key * Key to find in map * @return Index of matching key or -1 if not found */ private int findKey(final Object key) { if (size > 0) { // Find key starting at search index final int index = findKey(lastSearchIndex, key); // Found match? if (index != -1) { // Start search at the next index next time lastSearchIndex = nextIndex(index); // Return index of key return index; } } return -1; } /** * Searches for a key from a given starting index. * * @param key * The key to find in this map * @param start * Index to start at * @return Index of matching key or -1 if not found */ private int findKey(final int start, final Object key) { int i = start; do { if (key.equals(keys[i])) { return i; } i = nextIndex(i); } while (i != start); return -1; } /** * Searches for a value from a given starting index. * * @param start * Index to start at * @param value * The value to find in this map * @return Index of matching value or -1 if not found */ private int findValue(final int start, final Object value) { int i = start; do { if (value.equals(values[i])) { return i; } i = nextIndex(i); } while (i != start); return -1; } }