inthashmap.java

来自「Struts2 + Spring JPA Hibernate demo.」· Java 代码 · 共 813 行 · 第 1/2 页

	 *
	 * @param t      Mappings to be stored in this map.
	 */
	public void putAll(Map t) {
		Iterator i = t.entrySet().iterator();
		while (i.hasNext()) {
			Map.Entry e = (Map.Entry) i.next();
			put(e.getKey(), e.getValue());
		}
	}

	/**
	 * Removes all mappings from this map.
	 */
	public void clear() {
		Entry tab[] = table;
		modCount++;
		for (int index = tab.length; --index >= 0; ) {
			tab[index] = null;
		}
		count = 0;
	}

	/**
	 * Returns a shallow copy of this <code>IntHashMap</code> instance: the keys and
	 * values themselves are not cloned.
	 *
	 * @return a shallow copy of this map.
	 */
	public Object clone() {
		try {
			IntHashMap t = (IntHashMap)super.clone();
			t.table = new Entry[table.length];
			for (int i = table.length ; i-- > 0 ; ) {
				t.table[i] = (table[i] != null)
							 ? (Entry)table[i].clone() : null;
			}
			t.keySet = null;
			t.entrySet = null;
			t.values = null;
			t.modCount = 0;
			return t;
		} catch (CloneNotSupportedException e) {
			// this shouldn't happen, since we are Cloneable
			throw new InternalError();
		}
	}

	// views
	private transient Set keySet = null;
	private transient Set entrySet = null;
	private transient Collection values = null;

	/**
	 * Returns a set view of the keys contained in this map. The set is backed by
	 * the map, so changes to the map are reflected in the set, and vice-versa.
	 * The set supports element removal, which removes the corresponding mapping
	 * from this map, via the <code>Iterator.remove</code>,
	 * <code>Set.remove</code>, <code>removeAll</code>, <code>retainAll</code>,
	 * and <code>clear</code> operations. It does not support the
	 * <code>add</code> or <code>addAll</code> operations.
	 *
	 * @return a set view of the keys contained in this map.
	 */
	public Set keySet() {
		if (keySet == null) {
			keySet = new AbstractSet() {
				public Iterator iterator() {
					return new IntHashIterator(KEYS);
				}
				public int size() {
					return count;
				}
				public boolean contains(Object o) {
					return containsKey(o);
				}
				public boolean remove(Object o) {
					return IntHashMap.this.remove(o) != null;
				}
				public void clear() {
					IntHashMap.this.clear();
				}
			};
		}
		return keySet;
	}

	/**
	 * Returns a collection view of the values contained in this map. The
	 * collection is backed by the map, so changes to the map are reflected in
	 * the collection, and vice-versa. The collection supports element removal,
	 * which removes the corresponding mapping from this map, via the
	 * <code>Iterator.remove</code>, <code>Collection.remove</code>,
	 * <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>
	 * operations. It does not support the <code>add</code> or
	 * <code>addAll</code> operations.
	 *
	 * @return a collection view of the values contained in this map.
	 */
	public Collection values() {
		if (values==null) {
			values = new AbstractCollection() {
				public Iterator iterator() {
					return new IntHashIterator(VALUES);
				}
				public int size() {
					return count;
				}
				public boolean contains(Object o) {
					return containsValue(o);
				}
				public void clear() {
					IntHashMap.this.clear();
				}
			};
		}
		return values;
	}

	/**
	 * Returns a collection view of the mappings contained in this map. Each
	 * element in the returned collection is a <code>Map.Entry</code>. The
	 * collection is backed by the map, so changes to the map are reflected in
	 * the collection, and vice-versa. The collection supports element removal,
	 * which removes the corresponding mapping from the map, via the
	 * <code>Iterator.remove</code>, <code>Collection.remove</code>,
	 * <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>
	 * operations. It does not support the <code>add</code> or
	 * <code>addAll</code> operations.
	 *
	 * @return a collection view of the mappings contained in this map.
	 * @see java.util.Map.Entry
	 */
	public Set entrySet() {
		if (entrySet==null) {
			entrySet = new AbstractSet() {
				public Iterator iterator() {
					return new IntHashIterator(ENTRIES);
				}

				public boolean contains(Object o) {
					if (!(o instanceof Map.Entry)) {
						return false;
					}
					Map.Entry entry = (Map.Entry)o;
					Object key = entry.getKey();
					Entry tab[] = table;
					int hash = (key==null ? 0 : key.hashCode());
					int index = (hash & 0x7FFFFFFF) % tab.length;

					for (Entry e = tab[index]; e != null; e = e.next) {
						if (e.key == hash && e.equals(entry)) {
							return true;
						}
					}
					return false;
				}

				public boolean remove(Object o) {
					if (!(o instanceof Map.Entry))
						return false;
					Map.Entry entry = (Map.Entry)o;
					Object key = entry.getKey();
					Entry tab[] = table;
					int hash = (key==null ? 0 : key.hashCode());
					int index = (hash & 0x7FFFFFFF) % tab.length;

					for (Entry e = tab[index], prev = null; e != null;
						prev = e, e = e.next) {
						if (e.key == hash && e.equals(entry)) {
							modCount++;
							if (prev != null) {
								prev.next = e.next;
							} else {
								tab[index] = e.next;
							}

							count--;
							e.value = null;
							return true;
						}
					}
					return false;
				}

				public int size() {
					return count;
				}

				public void clear() {
					IntHashMap.this.clear();
				}
			};
		}

		return entrySet;
	}

	/**
	 * IntHashMap collision list entry.
	 */
	private static class Entry implements Map.Entry {
		int key;
		Object value;
		Entry next;
		private Integer objectKey;

		Entry(int key, Object value, Entry next) {
			this.key = key;
			this.value = value;
			this.next = next;
		}

		protected Object clone() {
			return new Entry(key, value,
							 (next==null ? null : (Entry)next.clone()));
		}

		// Map.Entry Ops

		public Object getKey() {
			return(objectKey != null) ? objectKey :
			(objectKey = new Integer(key));
		}

		public Object getValue() {
			return value;
		}

		public Object setValue(Object value) {
			Object oldValue = this.value;
			this.value = value;
			return oldValue;
		}

		public boolean equals(Object o) {
			if (!(o instanceof Map.Entry)) {
				return false;
			}
			Map.Entry e = (Map.Entry)o;

			return(getKey().equals(e.getKey())) &&
			(value==null ? e.getValue()==null : value.equals(e.getValue()));
		}

		public int hashCode() {
			return key ^ (value==null ? 0 : value.hashCode());
		}

		public String toString() {
			return String.valueOf(key) + "=" + value;
		}
	}

	// types of Iterators
	private static final int KEYS = 0;
	private static final int VALUES = 1;
	private static final int ENTRIES = 2;

	private class IntHashIterator implements Iterator {
		Entry[] table = IntHashMap.this.table;
		int index = table.length;
		Entry entry = null;
		Entry lastReturned = null;
		int type;

		/**
		 * The modCount value that the iterator believes that the backing
		 * List should have.  If this expectation is violated, the iterator
		 * has detected concurrent modification.
		 */
		private int expectedModCount = modCount;

		IntHashIterator(int type) {
			this.type = type;
		}

		public boolean hasNext() {
			while (entry == null && index > 0) {
				entry = table[--index];
			}

			return entry != null;
		}

		public Object next() {
			if (modCount != expectedModCount) {
				throw new ConcurrentModificationException();
			}

			while (entry == null && index > 0) {
				entry = table[--index];
			}

			if (entry != null) {
				Entry e = lastReturned = entry;
				entry = e.next;
				return type == KEYS ? e.getKey() :
				(type == VALUES ? e.value : e);
			}
			throw new NoSuchElementException();
		}

		public void remove() {
			if (lastReturned == null) {
				throw new IllegalStateException();
			}
			if (modCount != expectedModCount) {
				throw new ConcurrentModificationException();
			}

			Entry[] tab = IntHashMap.this.table;
			int index = (lastReturned.key & 0x7FFFFFFF) % tab.length;

			for (Entry e = tab[index], prev = null; e != null;
				prev = e, e = e.next) {
				if (e == lastReturned) {
					modCount++;
					expectedModCount++;
					if (prev == null) {
						tab[index] = e.next;
					} else {
						prev.next = e.next;
					}
					count--;
					lastReturned = null;
					return;
				}
			}
			throw new ConcurrentModificationException();
		}
	}

	/**
	 * Save the state of the <code>IntHashMap</code> instance to a stream (i.e.,
	 * serialize it).
	 * <p>
	 * Data The <i>capacity</i> of the IntHashMap (the length of the bucket
	 * array) is emitted (int), followed by the <i>size</i> of the IntHashMap
	 * (the number of key-value mappings), followed by the key (Object) and value
	 * (Object) for each key-value mapping represented by the IntHashMap The
	 * key-value mappings are emitted in no particular order.
	 *
	 * @param s
	 *
	 * @exception IOException
	 */
	private void writeObject(java.io.ObjectOutputStream s) throws IOException {
		// write out the threshold, loadfactor, and any hidden stuff
		s.defaultWriteObject();

		// write out number of buckets
		s.writeInt(table.length);

		// write out size (number of Mappings)
		s.writeInt(count);

		// write out keys and values (alternating)
		for (int index = table.length-1; index >= 0; index--) {
			Entry entry = table[index];

			while (entry != null) {
				s.writeInt(entry.key);
				s.writeObject(entry.value);
				entry = entry.next;
			}
		}
	}

	/**
	 * Reconstitute the <code>IntHashMap</code> instance from a stream (i.e.,
	 * deserialize it).
	 *
	 * @param s
	 *
	 * @exception IOException
	 * @exception ClassNotFoundException
	 */
	private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
		// read in the threshold, loadfactor, and any hidden stuff
		s.defaultReadObject();

		// read in number of buckets and allocate the bucket array;
		int numBuckets = s.readInt();
		table = new Entry[numBuckets];

		// read in size (number of Mappings)
		int size = s.readInt();

		// read the keys and values, and put the mappings in the IntHashMap
		for (int i=0; i<size; i++) {
			int key = s.readInt();
			Object value = s.readObject();
			put(key, value);
		}
	}

	int capacity() {
		return table.length;
	}

	float loadFactor() {
		return loadFactor;
	}
}