Java 哈希表：在发生冲突的情况下 Hashtable ht=newhashtable（）； 对于（int i=0；i
上面的代码片段正在打印99、98、…90 但我想打印所有100个元素。 如何获得一个数字列表，如。。。 99,89,79,69,...19,9 98,88,78,68....18,8 97,87,77,67....17,7 .. .. 91,81,71,61…11,1Java 哈希表：在发生冲突的情况下 Hashtable ht=newhashtable（）； 对于（int i=0；i,java,collections,hashtable,Java,Collections,Hashtable,上面的代码片段正在打印99、98、…90 但我想打印所有100个元素。 如何获得一个数字列表，如。。。 99,89,79,69,...19,9 98,88,78,68....18,8 97,87,77,67....17,7 .. .. 91,81,71,61…11,1 基本上所有冲突列表。您当前正在使用i%10作为哈希映射键，它只有十个值（0-9）。因此，只有最后十个值存储在地图中，所有其他值都被覆盖 如果需要在每个存储桶中存储多个项目，请使用列表类型作为值。例如： Hashtable h
基本上所有冲突列表。您当前正在使用
i%100-9 Hashtable ht = new Hashtable();
for (int i = 0; i < 100; i++) {
ht.put(i%10, i);
}
Enumeration< Integer> eles = ht.elements();
while(eles.hasMoreElements())
System.out.println(eles.nextElement());
Hashtable ht=newhashtable（）；
对于（int i=0；i<100；i++）{
int key=i%10；
列表=ht.get（键）；
if（list==null）{
列表=新的ArrayList（）；
ht.put（键、列表）；
}
列表.添加（i）；
}
枚举元素=ht.elements（）；
while（eles.hasMoreElements（））{
System.out.println（Arrays.toString（eles.nextElement（）.toArray（））；
}
Hashtable<Integer, List<Integer>> ht = new Hashtable<>();
for (int i = 0; i < 100; i++) {
int key = i % 10;
List<Integer> list = ht.get(key);
if (list == null) {
list = new ArrayList<>();
ht.put(key, list);
}
list.add(i);
}
Enumeration<List<Integer>> eles = ht.elements();
while (eles.hasMoreElements()) {
System.out.println(Arrays.toString(eles.nextElement().toArray()));
}
您当前正在使用
i%100-9 Hashtable ht = new Hashtable();
for (int i = 0; i < 100; i++) {
ht.put(i%10, i);
}
Enumeration< Integer> eles = ht.elements();
while(eles.hasMoreElements())
System.out.println(eles.nextElement());
Hashtable ht=newhashtable（）；
对于（int i=0；i<100；i++）{
int key=i%10；
列表=ht.get（键）；
if（list==null）{
列表=新的ArrayList（）；
ht.put（键、列表）；
}
列表.添加（i）；
}
枚举元素=ht.elements（）；
while（eles.hasMoreElements（））{
System.out.println（Arrays.toString（eles.nextElement（）.toArray（））；
}
Hashtable<Integer, List<Integer>> ht = new Hashtable<>();
for (int i = 0; i < 100; i++) {
int key = i % 10;
List<Integer> list = ht.get(key);
if (list == null) {
list = new ArrayList<>();
ht.put(key, list);
}
list.add(i);
}
Enumeration<List<Integer>> eles = ht.elements();
while (eles.hasMoreElements()) {
System.out.println(Arrays.toString(eles.nextElement().toArray()));
}
您在示例中观察到的是而不是碰撞效应。这是正常的元件更换。 在100次迭代之后，哈希表中只有10个元素 您使用数字i%10（0,1，…，9）作为键。所以，你只有10把不同的钥匙。 例如：在For循环中，为key=5（i=5，i=15，i=95）输入10个值，每个输入（5，val）替换与key=5关联的旧值 冲突列表是不同的概念。 对于每个键，哈希表计算一些哈希值，并使用此哈希选择其内部bucket表中的索引。接下来将{key，value}放在该索引下。 冲突是指两个不同的键计算了相同的bucket索引的情况 例如：
Hashtable ht = new Hashtable();
for (int i = 0; i < 100; i++) {
ht.put(i%10, i);
}
Enumeration< Integer> eles = ht.elements();
while(eles.hasMoreElements())
System.out.println(eles.nextElement());
table index | map.entry
0 | {0, "A"}
1 | {3, "B"}
2 | {2, "A"} -> {4, "C"}
3 | {1, "D"} -> {5, "A} -> {6, "F}
/**
*哈希表bucket冲突列表条目
*/
私有静态类条目实现Map.Entry{
整数散列；
最终K键；
V值；
进入下一步；
受保护的条目（int散列、K键、V值、下一个条目）{
this.hash=hash；
this.key=key；
这个值=值；
this.next=next；
}
...
公共V设置值（V值）{
如果（值==null）
抛出新的NullPointerException（）；
V oldValue=此值；
这个值=值；
返回旧值；
}
...
公共int hashCode（）{
返回哈希^value.hashCode（）；
}
...
/**
* Hashtable bucket collision list entry
*/
private static class Entry<K,V> implements Map.Entry<K,V> {
int hash;
final K key;
V value;
Entry<K,V> next;
protected Entry(int hash, K key, V value, Entry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
...
public V setValue(V value) {
if (value == null)
throw new NullPointerException();
V oldValue = this.value;
this.value = value;
return oldValue;
}
...
public int hashCode() {
return hash ^ value.hashCode();
}
...
/**
*哈希表数据。
*/
私有瞬态条目[]表；
希望这有助于找出哈希表的行为。您在示例中观察到的是而不是碰撞效应。这是正常的元件更换。 在100次迭代之后，哈希表中只有10个元素 您使用数字i%10（0,1，…，9）作为键。所以，你只有10把不同的钥匙。 例如：在For循环中，为key=5（i=5，i=15，i=95）输入10个值，每个输入（5，val）替换与key=5关联的旧值 冲突列表是不同的概念。 对于每个键，哈希表计算一些哈希值，并使用此哈希选择其内部bucket表中的索引。接下来将{key，value}放在该索引下。 冲突是指两个不同的键计算了相同的bucket索引的情况 例如：
Hashtable ht = new Hashtable();
for (int i = 0; i < 100; i++) {
ht.put(i%10, i);
}
Enumeration< Integer> eles = ht.elements();
while(eles.hasMoreElements())
System.out.println(eles.nextElement());