lighthashmap.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   LightHashMap.java

package org.gudy.azureus2.core3.util;

import java.io.PrintStream;
import java.util.*;

public class LightHashMap extends AbstractMap
	implements Cloneable
{
	private class EntrySet extends AbstractSet
	{
		private class EntrySetIterator extends HashIterator
		{
			private final class Entry
				implements java.util.Map.Entry
			{

				final int entryIndex;
				final EntrySetIterator this$2;

				public Object getKey()
				{
					Object key = itData[entryIndex];
					return key == LightHashMap.NULLKEY ? null : key;
				}

				public Object getValue()
				{
					return itData[entryIndex + 1];
				}

				public Object setValue(Object value)
				{
					Object oldValue = itData[entryIndex + 1];
					itData[entryIndex + 1] = value;
					return oldValue;
				}

				public boolean equals(Object o)
				{
					if (!(o instanceof java.util.Map.Entry))
					{
						return false;
					} else
					{
						java.util.Map.Entry e = (java.util.Map.Entry)o;
						return (getKey() != null ? getKey().equals(e.getKey()) : e.getKey() == null) && (getValue() != null ? getValue().equals(e.getValue()) : e.getValue() == null);
					}
				}

				public int hashCode()
				{
					return (getKey() != null ? getKey().hashCode() : 0) ^ (getValue() != null ? getValue().hashCode() : 0);
				}

				public Entry(int idx)
				{
					this$2 = EntrySetIterator.this;
					super();
					entryIndex = idx;
				}
			}


			final EntrySet this$1;

			public Object nextIntern()
			{
				return new LightHashMap.EntrySet.EntrySetIterator.Entry(currentIdx);
			}

			private EntrySetIterator()
			{
				this$1 = EntrySet.this;
				super();
			}

		}


		final LightHashMap this$0;

		public Iterator iterator()
		{
			return new EntrySetIterator();
		}

		public int size()
		{
			return LightHashMap.this.size;
		}

		private EntrySet()
		{
			this$0 = LightHashMap.this;
			super();
		}

	}

	private abstract class HashIterator
		implements Iterator
	{

		protected int nextIdx;
		protected int currentIdx;
		protected Object itData[];
		final LightHashMap this$0;

		private void findNext()
		{
			do
				nextIdx += 2;
			while (nextIdx < itData.length && (itData[nextIdx] == null || itData[nextIdx] == LightHashMap.THOMBSTONE));
		}

		public void remove()
		{
			if (currentIdx == -2)
				throw new IllegalStateException("No entry to delete, use next() first");
			if (itData != data)
			{
				throw new ConcurrentModificationException("removal opperation not supported as concurrent structural modification occured");
			} else
			{
				removeForIndex(currentIdx);
				currentIdx = -2;
				return;
			}
		}

		public boolean hasNext()
		{
			return nextIdx < itData.length;
		}

		public Object next()
		{
			if (!hasNext())
			{
				throw new IllegalStateException("No more entries");
			} else
			{
				currentIdx = nextIdx;
				findNext();
				return nextIntern();
			}
		}

		abstract Object nextIntern();

		public HashIterator()
		{
			this$0 = LightHashMap.this;
			super();
			nextIdx = -2;
			currentIdx = -2;
			itData = data;
			findNext();
		}
	}

	private class KeySet extends AbstractSet
	{
		private class KeySetIterator extends HashIterator
		{

			final KeySet this$1;

			Object nextIntern()
			{
				Object key = itData[currentIdx];
				return key == LightHashMap.NULLKEY ? null : key;
			}

			private KeySetIterator()
			{
				this$1 = KeySet.this;
				super();
			}

		}


		final LightHashMap this$0;

		public Iterator iterator()
		{
			return new KeySetIterator();
		}

		public int size()
		{
			return LightHashMap.this.size;
		}

		private KeySet()
		{
			this$0 = LightHashMap.this;
			super();
		}

	}

	private class Values extends AbstractCollection
	{
		private class ValueIterator extends HashIterator
		{

			final Values this$1;

			Object nextIntern()
			{
				return itData[currentIdx + 1];
			}

			private ValueIterator()
			{
				this$1 = Values.this;
				super();
			}

		}


		final LightHashMap this$0;

		public Iterator iterator()
		{
			return new ValueIterator();
		}

		public int size()
		{
			return LightHashMap.this.size;
		}

		private Values()
		{
			this$0 = LightHashMap.this;
			super();
		}

	}


	private static final Object THOMBSTONE = new Object();
	private static final Object NULLKEY = new Object();
	private static final float DEFAULT_LOAD_FACTOR = 0.75F;
	private static final int DEFAULT_CAPACITY = 8;
	final float loadFactor;
	int size;
	Object data[];

	public LightHashMap()
	{
		this(8, 0.75F);
	}

	public LightHashMap(int initialCapacity)
	{
		this(initialCapacity, 0.75F);
	}

	public LightHashMap(Map m)
	{
		this(0);
		if (m instanceof LightHashMap)
		{
			LightHashMap lightMap = (LightHashMap)m;
			size = lightMap.size;
			data = (Object[])(Object[])((Object []) (lightMap.data)).clone();
		} else
		{
			putAll(m);
		}
	}

	public Object clone()
	{
		LightHashMap newMap;
		newMap = (LightHashMap)super.clone();
		newMap.data = (Object[])(Object[])((Object []) (data)).clone();
		return newMap;
		CloneNotSupportedException e;
		e;
		e.printStackTrace();
		throw new RuntimeException(e);
	}

	public LightHashMap(int initialCapacity, float loadFactor)
	{
		if (loadFactor > 1.0F)
			throw new IllegalArgumentException("Load factor must not be > 1");
		this.loadFactor = loadFactor;
		int capacity;
		for (capacity = 1; capacity < initialCapacity; capacity <<= 1);
		data = new Object[capacity * 2];
	}

	public Set entrySet()
	{
		return new EntrySet();
	}

	public Object put(Object key, Object value)
	{
		checkCapacity(1);
		return add(key, value, false);
	}

	public void putAll(Map m)
	{
		checkCapacity(m.size());
		java.util.Map.Entry entry;
		for (Iterator it = m.entrySet().iterator(); it.hasNext(); add(entry.getKey(), entry.getValue(), true))
			entry = (java.util.Map.Entry)it.next();

	}

	public Set keySet()
	{
		return new KeySet();
	}

	public Collection values()
	{
		return new Values();
	}

	public int capacity()
	{
		return data.length >> 1;
	}

	public Object get(Object key)
	{
		if (key == null)