Hash类的实现

package Hash;
import java.util.ConcurrentModificationException;
import java.util.NoSuchElementException;
import MyInterface.*;

/**
* Hash类的实现
*/
public class Hash<T> implements Collection<T> {

// ----------------------------------------------------------------
// 结点类
private static class Entry<T> {
T value;
int hashValue;
Entry<T> next;

public Entry(T value, int hashValue, Entry<T> next) {
this.value = value;
this.hashValue = hashValue;
this.next = next;
}
}

// ----------------------------------------------------------------
// Hash类实例变量
private Entry[] table;
private int hashTableSize;
private final double MAX_LOAD_FACTOR = 0.75;
private int tableThreshold;
private int modCount = 0;

// Hash类构造函数
public Hash() {
table = new Entry[17];
hashTableSize = 0;
tableThreshold = (int) (table.length * MAX_LOAD_FACTOR);
}

// ----------------------------------------------------------------
// add()方法
public boolean add(T item) {
int hashValue = item.hashCode() & Integer.MAX_VALUE, index = hashValue
% table.length;
Entry<T> entry;
entry = table[index];

while (entry != null) {
if (entry.value.equals(item))
return false;
entry = entry.next;
}
modCount++;
entry = new Entry<T>(item, hashValue, (Entry<T>) table[index]);
table[index] = entry;
hashTableSize++;
if (hashTableSize >= tableThreshold)
rehash(2 * table.length + 1);
return true;
}

// 散列表的再散列
private void rehash(int newTableSize) {
Entry[] newTable = new Entry[newTableSize], oldTable = table;
Entry<T> entry, nextEntry;
int index;

for (int i = 0; i < table.length; i++) {
entry = table[i];
if (entry != null) {
table[i] = null;
do {
nextEntry = entry.next;
index = entry.hashValue % newTableSize;
entry.next = newTable[index];
newTable[index] = entry;
entry = nextEntry;
} while (entry != null);
}
}
table = newTable;
tableThreshold = (int) (table.length * MAX_LOAD_FACTOR);
oldTable = null;
}

// remove()方法
public boolean remove(Object item) {
int index = ((item.hashCode() & Integer.MAX_VALUE)) % table.length;
Entry<T> curr, prev;
curr = table[index];
prev = null;
while (curr != null) {
if (curr.value.equals(item)) {
modCount++;
if (prev != null)
prev.next = curr.next;
else
table[index] = curr.next;
hashTableSize--;
return true;

} else {
prev = curr;
curr = curr.next;
}
}
return false;
}

public void clear() {
int len = table.length;
for (int i=0;i < len; i++)
table[i] = null;
modCount++;
hashTableSize = 0;
}

public boolean contains(Object item) {
int index = (item.hashCode() & Integer.MAX_VALUE) % table.length;
Entry<T> entry;
entry = table[index];
while (entry != null) {
if (entry.value.equals(item))
return true;
entry = entry.next;
}
return false;
}

public boolean isEmpty() {
return hashTableSize == 0;
}

public Iterator<T> iterator() {
return new MyIterator();
}

public int size() {
return hashTableSize;
}

public Object[] toArray() {
Object[] arr = new Object[hashTableSize];
Iterator<T> iter = iterator();
for(int i = 0; iter.hasNext(); i++)
arr[i] = iter.next();
return arr;
}

public String toString() {
int max = hashTableSize - 1;
StringBuffer buf = new StringBuffer();
Iterator<T> iter = iterator();

buf.append("[");
for (int i = 0; i <= max; i++)
{
buf.append(iter.next());

if (i < max)
buf.append(", ");
}
buf.append("]");
return buf.toString();
}

private class MyIterator implements Iterator<T> {

Entry<T> next;
int expectedModCount;
int index;
T lastReturned;

//构造函数
MyIterator() {
int i = 0;
Entry<T> n = null;
expectedModCount = modCount;
if(hashTableSize != 0) {
while(i < table.length && ((n = table[i]) == null))
i++;
}
next = n;
index = i;
lastReturned = null;
}

public boolean hasNext() {
return next != null;
}

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

Entry<T> entry = next;

if (entry == null)
throw new NoSuchElementException();
lastReturned = entry.value;
Entry<T> n = entry.next;
int i = index;
if (n == null) {
i++;
while (i < table.length && ((n = table[i]) == null))
i++;
}
index = i;
next = n;
return lastReturned;
}

public void remove() {
// check for a missing call to next() or previous()
if (lastReturned == null)
throw new IllegalStateException(
"Iterator call to next() " +
"required before calling remove()");
if (modCount != expectedModCount)
throw new ConcurrentModificationException();

// remove lastReturned by calling remove() in Hash.
// this call will increment modCount
Hash.this.remove(lastReturned);
expectedModCount = modCount;
lastReturned = null;
}

}

}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值