how2j.cn

本视频是解读性视频,所以希望您已经看过了本知识点的内容,并且编写了相应的代码之后,带着疑问来观看,这样收获才多。 不建议一开始就观看视频



20分40秒
本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)



步骤 1 : List查找的低效率   
步骤 2 : HashMap的性能表现   
步骤 3 : HashMap原理与字典   
步骤 4 : 分析HashMap性能卓越的原因   
步骤 5 : HashSet判断是否重复   
步骤 6 : 练习-自定义字符串的hashcode   
步骤 7 : 答案-自定义字符串的hashcode   
步骤 8 : 练习-自定义MyHashMap   
步骤 9 : 答案-自定义MyHashMap   
步骤 10 : 练习-内容查找性能比较   
步骤 11 : 答案-内容查找性能比较   

步骤 1 :

List查找的低效率

edit
假设在List中存放着无重复名称,没有顺序的2000000个Hero
要把名字叫做“hero 1000000”的对象找出来
List的做法是对每一个进行挨个遍历,直到找到名字叫做“hero 1000000”的英雄。
最差的情况下,需要遍历和比较2000000次,才能找到对应的英雄。
测试逻辑:
1. 初始化2000000个对象到ArrayList中
2. 打乱容器中的数据顺序
3. 进行10次查询,统计每一次消耗的时间
不同计算机的配置情况下,所花的时间是有区别的。 在本机上,花掉的时间大概是600毫秒左右
List查找的低效率
package collection; import java.util.ArrayList; import java.util.Collections; import java.util.List; import charactor.Hero; public class TestCollection { public static void main(String[] args) { List<Hero> heros = new ArrayList<Hero>(); for (int j = 0; j < 2000000; j++) { Hero h = new Hero("Hero " + j); heros.add(h); } // 进行10次查找,观察大体的平均值 for (int i = 0; i < 10; i++) { // 打乱heros中元素的顺序 Collections.shuffle(heros); long start = System.currentTimeMillis(); String target = "Hero 1000000"; for (Hero hero : heros) { if (hero.name.equals(target)) { System.out.println("找到了 hero!" ); break; } } long end = System.currentTimeMillis(); long elapsed = end - start; System.out.println("一共花了:" + elapsed + " 毫秒"); } } }
步骤 2 :

HashMap的性能表现

edit
使用HashMap 做同样的查找
1. 初始化2000000个对象到HashMap中。
2. 进行10次查询
3. 统计每一次的查询消耗的时间
可以观察到,几乎不花时间,花费的时间在1毫秒以内
HashMap的性能表现
package collection; import java.util.HashMap; import charactor.Hero; public class TestCollection { public static void main(String[] args) { HashMap<String,Hero> heroMap = new HashMap<String,Hero>(); for (int j = 0; j < 2000000; j++) { Hero h = new Hero("Hero " + j); heroMap.put(h.name, h); } System.out.println("数据准备完成"); for (int i = 0; i < 10; i++) { long start = System.currentTimeMillis(); //查找名字是Hero 1000000的对象 Hero target = heroMap.get("Hero 1000000"); System.out.println("找到了 hero!" + target.name); long end = System.currentTimeMillis(); long elapsed = end - start; System.out.println("一共花了:" + elapsed + " 毫秒"); } } }
步骤 3 :

HashMap原理与字典

edit
在展开HashMap原理的讲解之前,首先回忆一下大家初中和高中使用的汉英字典。

比如要找一个单词对应的中文意思,假设单词是Lengendary,首先在目录找到Lengendary在第 555页。

然后,翻到第555页,这页不只一个单词,但是量已经很少了,逐一比较,很快就定位目标单词Lengendary。

555相当于就是Lengendary对应的hashcode
步骤 4 :

分析HashMap性能卓越的原因

edit
-----hashcode概念-----
所有的对象,都有一个对应的hashcode(散列值)
比如字符串“gareen”对应的是1001 (实际上不是,这里是方便理解,假设的值)
比如字符串“temoo”对应的是1004
比如字符串“db”对应的是1008
比如字符串“annie”对应的是1008

-----保存数据-----
准备一个数组,其长度是2000,并且设定特殊的hashcode算法,使得所有字符串对应的hashcode,都会落在0-1999之间
要存放名字是"gareen"的英雄,就把该英雄和名称组成一个键值对,存放在数组的1001这个位置上
要存放名字是"temoo"的英雄,就把该英雄存放在数组的1004这个位置上
要存放名字是"db"的英雄,就把该英雄存放在数组的1008这个位置上
要存放名字是"annie"的英雄,然而 "annie"的hashcode 1008对应的位置已经有db英雄了,那么就在这里创建一个链表,接在db英雄后面存放annie

-----查找数据-----
比如要查找gareen,首先计算"gareen"的hashcode是1001,根据1001这个下标,到数组中进行定位,(根据数组下标进行定位,是非常快速的) 发现1001这个位置就只有一个英雄,那么该英雄就是gareen.
比如要查找annie,首先计算"annie"的hashcode是1008,根据1008这个下标,到数组中进行定位,发现1008这个位置有两个英雄,那么就对两个英雄的名字进行逐一比较(equals),因为此时需要比较的量就已经少很多了,很快也就可以找出目标英雄
这就是使用hashmap进行查询,非常快原理。


这是一种用空间换时间的思维方式
分析HashMap性能卓越的原因
步骤 5 :

HashSet判断是否重复

edit
HashSet的数据是不能重复的,相同数据不能保存在一起,到底如何判断是否是重复的呢?
根据HashSet和HashMap的关系,我们了解到因为HashSet没有自身的实现,而是里面封装了一个HashMap,所以本质上就是判断HashMap的key是否重复。

再通过上一步的学习,key是否重复,是由两个步骤判断的:
hashcode是否一样
如果hashcode不一样,就是在不同的坑里,一定是不重复的
如果hashcode一样,就是在同一个坑里,还需要进行equals比较
如果equals一样,则是重复数据
如果equals不一样,则是不同数据。
步骤 6 :

练习-自定义字符串的hashcode

edit Or  姿势不对,事倍功半! 点击查看做练习的正确姿势
如下是Java API提供的String的hashcode生成办法;

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

s[0] 表示第一位字符
n表示字符串的长度
本练习并不是要求去理解这个算法,而是自定义一个简单的hashcode算法,计算任意字符串的hashcode
因为String类不能被重写,所以我们通过一个静态方法来返回一个String的hashcode

public static int hashcode(String)

如果字符串长度是0,则返回0。
否则: 获取每一位字符,转换成数字后,相加,最后乘以23

(s[0]+ s[1] + s[2] + s[3]+ s[n-1])*23.

如果值超过了1999,则取2000的余数,保证落在0-1999之间。
如果是负数,则取绝对值。

随机生成长度是2-10的不等的100个字符串,打印用本hashcode获取的值分别是多少
步骤 7 :

答案-自定义字符串的hashcode

edit
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
账号未激活 账号未激活,功能受限。 请点击激活
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

8分57秒 本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)


答案-自定义字符串的hashcode
package collection; public class TestCollection { public static void main(String[] args) { for (int i = 0; i < 100; i++) { int length = (int) (Math.random()*8+2); String str = randomString(length); int hashcode = hashcode(str); System.out.printf("%-11s的自定义hashcode是:%d%n",str,hashcode); } } private static int hashcode(String str) { // TODO Auto-generated method stub if(0==str.length()) return 0; int hashcode = 0; char[]cs= str.toCharArray(); for (int i = 0; i < cs.length; i++) { hashcode +=cs[i]; } hashcode*=23; //取绝对值 hashcode = hashcode<0?0-hashcode:hashcode; //落在0-1999之间 hashcode %=2000; return hashcode; } private static String randomString(int length) { String pool = ""; for (short i = '0'; i <= '9'; i++) { pool += (char) i; } for (short i = 'a'; i <= 'z'; i++) { pool += (char) i; } for (short i = 'A'; i <= 'Z'; i++) { pool += (char) i; } char cs[] = new char[length]; for (int i = 0; i < cs.length; i++) { int index = (int) (Math.random() * pool.length()); cs[i] = pool.charAt(index); } String result = new String(cs); return result; } }
步骤 8 :

练习-自定义MyHashMap

edit Or  姿势不对,事倍功半! 点击查看做练习的正确姿势
根据前面学习的hashcode的原理和自定义hashcode, 设计一个MyHashMap,实现接口IHashMap

MyHashMap内部由一个长度是2000的对象数组实现。

设计put(String key,Object value)方法
首先通过上一个自定义字符串的hashcode练习获取到该字符串的hashcode,然后把这个hashcode作为下标,定位到数组的指定位置。
如果该位置没有数据,则把字符串和对象组合成键值对Entry,再创建一个LinkedList,把键值对,放进LinkedList中,最后把LinkedList 保存在这个位置。
如果该位置有数据,一定是一个LinkedList,则把字符串和对象组合成键值对Entry,插入到LinkedList后面。

设计 Object get(String key) 方法
首先通过上一个自定义字符串的hashcode练习获取到该字符串的hashcode,然后把这个hashcode作为下标,定位到数组的指定位置。
如果这个位置没有数据,则返回空
如果这个位置有数据,则挨个比较其中键值对的键-字符串,是否equals,找到匹配的,把键值对的值,返回出去。找不到匹配的,就返回空
package collection; public interface IHashMap { public void put(String key,Object object); public Object get(String key); }
package collection; //键值对 package collection; //键值对 public class Entry { public Entry(Object key, Object value) { super(); this.key = key; this.value = value; } public Object key; public Object value; @Override public String toString() { return "[key=" + key + ", value=" + value + "]"; } }
步骤 9 :

答案-自定义MyHashMap

edit
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
查看本答案会花费5个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
查看本答案会花费5个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
账号未激活 账号未激活,功能受限。 请点击激活
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

11分24秒 本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)


package collection; import java.util.LinkedList; public class MyHashMap implements IHashMap { LinkedList<Entry>[] values = new LinkedList[2000]; @Override public void put(String key, Object object) { // 拿到hashcode int hashcode = hashcode(key); // 找到对应的LinkedList LinkedList<Entry> list = values[hashcode]; // 如果LinkedList是null,则创建一个LinkedList if (null == list) { list = new LinkedList<>(); values[hashcode] = list; } // 判断该key是否已经有对应的键值对 boolean found = false; for (Entry entry : list) { // 如果已经有了,则替换掉 if (key.equals(entry.key)) { entry.value = object; found = true; break; } } // 如果没有已经存在的键值对,则创建新的键值对 if (!found) { Entry entry = new Entry(key, object); list.add(entry); } } @Override public Object get(String key) { // 获取hashcode int hashcode = hashcode(key); // 找到hashcode对应的LinkedList LinkedList<Entry> list = values[hashcode]; if (null == list) return null; Object result = null; // 挨个比较每个键值对的key,找到匹配的,返回其value for (Entry entry : list) { if (entry.key.equals(key)) { result = entry.value; break; } } return result; } private static int hashcode(String str) { // TODO Auto-generated method stub if (0 == str.length()) return 0; int hashcode = 0; char[] cs = str.toCharArray(); for (int i = 0; i < cs.length; i++) { hashcode += cs[i]; } hashcode *= 23; // 取绝对值 hashcode = hashcode < 0 ? 0 - hashcode : hashcode; // 落在0-1999之间 hashcode %= 2000; return hashcode; } public static void main(String[] args) { MyHashMap map =new MyHashMap(); // // map.put("t", "坦克"); // map.put("adc", "物理"); // map.put("apc", "魔法"); // map.put("t", "坦克2"); // // System.out.println(map.get("adc")); // // System.out.println(map); System.out.println(map.hashcode("name=hero-2387")); System.out.println(map.hashcode("name=hero-5555")); } public String toString() { LinkedList<Entry> result = new LinkedList(); for (LinkedList<Entry> linkedList : values) { if (null == linkedList) continue; result.addAll(linkedList); } return result.toString(); } }
步骤 10 :

练习-内容查找性能比较

edit Or  姿势不对,事倍功半! 点击查看做练习的正确姿势
重复前面的 练习-查找内容性能比较 ,不过不使用HashMap,而是使用上个练习中自定义的MyHashMap.

准备一个ArrayList其中存放100000(十万个)Hero对象,其名称是随机的,格式是hero-[4位随机数]
hero-3229
hero-6232
hero-9365
...

因为总数很大,所以几乎每种都有重复,把名字叫做 hero-5555的所有对象找出来
要求使用两种办法来寻找
1. 不使用MyHashMap,直接使用for循环找出来,并统计花费的时间
2. 借助MyHashMap,找出结果,并统计花费的时间
步骤 11 :

答案-内容查找性能比较

edit
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
账号未激活 账号未激活,功能受限。 请点击激活
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

3分3秒 本视频采用html5方式播放,如无法正常播放,请将浏览器升级至最新版本,推荐火狐,chrome,360浏览器 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)


package collection; import java.util.ArrayList; import java.util.List; import charactor.Hero; public class TestCollection { public static void main(String[] args) { List<Hero> hs =new ArrayList<>(); System.out.println("初始化开始"); for (int i = 0; i < 100000; i++) { Hero h = new Hero( "hero-" + random()); hs.add(h); } //名字作为key //名字相同的hero,放在一个List中,作为value MyHashMap heroMap =new MyHashMap(); for (Hero h : hs) { List<Hero> list= (List<Hero>) heroMap.get( h.name); if(list==null){ list = new ArrayList<>(); heroMap.put(h.name, list); } list.add(h); } System.out.println("初始化结束"); System.out.println("开始查找"); findByIteration(hs); findByMap(heroMap); } private static List<Hero> findByMap(MyHashMap m) { long start =System.currentTimeMillis(); List <Hero>result= (List<Hero>) m.get("hero-5555"); long end =System.currentTimeMillis(); System.out.printf("通过map查找,一共找到%d个英雄,耗时%d 毫秒%n",result.size(),end-start); return result; } private static List<Hero> findByIteration (List<Hero> hs) { long start =System.currentTimeMillis(); List<Hero> result =new ArrayList<>(); for (Hero h : hs) { if(h.name.equals("hero-5555")){ result.add(h); } } long end =System.currentTimeMillis(); System.out.printf("通过for查找,一共找到%d个英雄,耗时%d 毫秒%n", result.size(),end-start); return result; } public static int random(){ return ((int)(Math.random()*9000)+1000); } }


HOW2J公众号,关注后实时获知布最新的教程和优惠活动,谢谢。


问答区域    
2019-02-16 我是调用了HashMap搞得,结果写完我自己都看不懂了
wodejb25cm



搞了好几个小时 结果 A [age=1] A [age=10]
public class Practice {
	private LinkedList<Set<Map.Entry<String, Object>>>[] array;
	
	public Practice () {
		array = new LinkedList[2000];
	}
	
	public void put(String Key,Object obj){
		//创建Map集合;并将参数中的实参传入
		HashMap<String ,Object> map = new HashMap<>();
		map.put(Key, obj);
		//获取Map的Set键值对象
		Set<Map.Entry<String, Object>> set = map.entrySet();
		//获取哈希值
		int hashcode = hashcode(Key);
		
		//获取数组中当前索引里的内容
		LinkedList<Set<Map.Entry<String, Object>>> quote = array[hashcode];
		
		 //判断当前数组位置有没有内容
		if(null==quote) {
			//没有的话,创建一个链表对象,把键值对象加进当前数组位置
			LinkedList<Set<Map.Entry<String, Object>>> list = new LinkedList<>();
			list.add(set);
			array[hashcode] = list;
		}
		else {
			//有的话则判断是否同一内容
			boolean flag = false;
			//通过双循环获取键值对对象
			for (Set<Map.Entry<String, Object>> it : quote) {
				for (Map.Entry<String, Object>  entry : it) {
					//如果为同一内容,则覆盖
					if(entry.getKey().equals(Key)) {
						entry.setValue(obj);
						flag = true;
					break;
					}
				}
			}
			//如果为不同内容,则存入
			if(!flag) {
				quote.add(set);
			}	
		}
	}
	//取出键对应的值
	public Object get(String Key) {
		int hashcode = hashcode(Key);
		LinkedList<Set<Map.Entry<String, Object>>> quote = array[hashcode];
		for (Set<Map.Entry<String, Object>> it : quote) {
			for (Map.Entry<String, Object>  entry : it) {
				if(entry.getKey().equals(Key)) {
					return	entry.getValue();
				}
				
			}
		}
		
		return null;
	}
	
	public static void main(String[] args) {
	
		Practice pra = new Practice();
				
		pra.put("a1", new A(1));
		pra.put("a10", new A(2));
		pra.put("a3", new A(3));
		pra.put("a4", new A(4));
		pra.put("a5", new A(5));
		pra.put("a10", new A(6));
		pra.put("a7", new A(7));
		pra.put("a10", new A(8));
		pra.put("a9", new A(9));
		pra.put("a10", new A(10));
		
		System.out.println(pra.get("a1"));
                System.out.println(pra.get("a10"));
		
		
		
	}
	//哈希值
	private static int hashcode(String str) {
        if (0 == str.length())
            return 0;
 
        int hashcode = 0;
        char[] cha = str.toCharArray();
        for (int i = 0; i < cha.length; i++) {
            hashcode += cha[i];
        }
        hashcode *= 23;
        // 取绝对值
        hashcode = hashcode < 0 ? 0 - hashcode : hashcode;
        // 落在0-1999之间
        hashcode %= 2000;
 
        return hashcode;
    }
}
class A{
	private int age;
	
	public A(int age) {
		this.age = age;
				
	}
	
	public int get() {
		return this.age;
	}

	@Override
	public String toString() {
		return "A [age=" + age + "]";
	}
		
}

							





回答已经提交成功,正在审核。 请于 我的回答 处查看回答记录,谢谢
答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2019-02-04 作业(完整)
逝月



其实作业已经给出了比较详细的实现思路,只需要跟着做即可,理解了hashmap的原理,思路还是很清晰的。 把我卡到的地方,是最后比较性能时,如何利用hashmap的特点来寻找名称重复的对象呢?由于偷懒了一段时间,我才想到之前利用数组作为值的方法。 然而,我傻傻的在myhashmap上改半天,之后才试着在初始化时做到这一点。绕了些弯,默默嫌弃自己几秒
package how2j;
import java.util.LinkedList;
import java.util.ArrayList;

public class MyHashMap implements IHashMap{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<Hero> al=new ArrayList<>();
		MyHashMap mhm=new MyHashMap();
		//初始化
		for(int i=0;i<100000;i++)
		{
			int r=(int)(Math.random()*9000+1000);
			String name="hero-"+r;
			Hero h=new Hero(name);
			al.add(h);
			//注意这里,把相同名字的Hero对象放在一个数组里,作为值			
			if(mhm.get(h.name)==null)
			{
				ArrayList<Hero> alh=new ArrayList<>();
				alh.add(h);
				mhm.put(h.name, alh);
			}
			else
			{
				ArrayList<Hero> alh=(ArrayList<Hero>)mhm.get(h.name);
				alh.add(h);
				//mhm.put(h.name, alh);
			}
		}
		//for循环查找
		long start=System.currentTimeMillis();
		for(int i=0;i<100000;i++)
		{
			if(al.get(i).name.equals("hero-5555"))
				System.out.println("抓住一只!");
		}
		long end1=System.currentTimeMillis();
		//myhashmap查找
		ArrayList<Hero> ar=(ArrayList<Hero>)mhm.get("hero-5555");
			for(Hero h:ar)
			{
				System.out.println("我也抓到一只!");
			}
		long end2=System.currentTimeMillis();
		System.out.println("for循环所用时间:"+(end1-start));
		System.out.println("myhashmap所用时间:"+(end2-end1));
	}
	
	Object [] o=new Object[2000];
	
    public void put(String key,Object object)
    {
    	int code=hashcode(key);
    	//该位置没有数据
    	if(o[code]==null)
    	{
    		LinkedList<Entry> ll=new LinkedList<>();
    		Entry e=new Entry(key,object);   		
    		ll.add(e);
    		o[code]=ll;
    	}
    	//该位置已有数据
    	else
    	{
    		LinkedList<Entry> ll=(LinkedList<Entry>)o[code];
    		for(Entry e:ll)
    		{
    			//如果出现key值重复则替换
    			if(e.key.equals(key))
    			{
    				e.value=object;
    				return;
    			}    				
    		}
    		Entry e=new Entry(key,object);   		
    		ll.add(e);
    		o[code]=ll;
    	}
    }
    
    public Object get(String key)
    {
    	int code=hashcode(key);
    	if(o[code]==null)
    	{
    		return null;
    	}
    	else
    	{
    		LinkedList<Entry> ll=(LinkedList<Entry>)o[code]; 
    		for(Entry e:ll)
    		{
    			//查找到对应的key
    			if(key.equals(e.key))  			
    				return e.value;  
    		}
				return null;
    	}
    }
    
  //自定义hashcode
  	public static int hashcode(String s)
  	{
  		int hash=0;
  		if(s.length()==0)
  			return 0;
  		for(int i=0;i<s.length();i++)
  		{
  			hash+=(int)s.charAt(i);
  		}
  		hash*=23;
  			 if(hash<0)
  			return Math.abs(hash);
  		else if(hash<=1999)
  			return hash;
  		else
  			return hash%2000;
  	}
}
这里我突然产生了对于java中值传递与引用传递的疑惑,之前明明查过资料的……





回答已经提交成功,正在审核。 请于 我的回答 处查看回答记录,谢谢
答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2018-12-11 练习3的 List<Hero> list= (List<Hero>) mhm.get(h.name);这个如果删掉(List<Hero>)就报错。
2018-12-04 为什么这里用linkedlist不用arraylist呢
2018-12-04 自定义的myhashmap中的if(null==list){}
2018-10-09 作业题三:不知道为什么会跳空指针异常,求解答!!
2018-10-09 作业题二
2018-10-01 MyHashMap构建耗时过长
2018-09-26 作业题一:自己按照自己思路写的,不知麻烦没有,应该可以更简化一点!
2018-09-21 自定义HashMap
2018-09-17 步骤9的视频看不了????
2018-09-02 第一题
2018-09-01 练习2中问题
2018-08-27 谁能告诉我,下面的Arrylist和HashMap代码生成的数量都是一样,代码一样,但两个相同的个数千查万别,HashMap生成的相同的有好多个
2018-08-04 作业
2018-07-31 交作业
2018-05-07 【提问】关于hashcode
2018-03-30 交作业
2018-01-03 对步骤4以空间换时间有疑问
2017-12-26 关于hashcode()方法的小疑问?
2017-11-13 LinkedList<Entry>[] myMap = new LinkedList[2000] 出现警告
2017-10-22 问题二的不解
2017-08-25 关于练习二中集合数组的疑问
2017-08-22 练习中关于LinkedHashSet的问题
2017-06-30 关于hashmap
2017-06-08 第1次,第2次。。。等等,是怎么打印出来的?
2017-05-29 为什么说“根据数组下标进行定位,是非常快速的”
2017-04-19 为什么只传入一个字符串,hashcode值会超过2000呢????
2017-04-18 我用ArrayList中indexOf方法查找hero 1000000,所用的时间跟HashMap没有差别额
2017-03-12 关于Entry




提问之前请登陆
提问已经提交成功,正在审核。 请于 我的提问 处查看提问记录,谢谢
关于 JAVA 中级-集合框架-hashcode 原理 的提问

尽量提供截图代码异常信息,有助于分析和解决问题。 也可进本站QQ群交流: 984886441
提问尽量提供完整的代码,环境描述,越是有利于问题的重现,您的问题越能更快得到解答。
对教程中代码有疑问,请提供是哪个步骤,哪一行有疑问,这样便于快速定位问题,提高问题得到解答的速度
在已经存在的几千个提问里,有相当大的比例,是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本,可以节约自己大量的学习时间。 站长把教学中用的软件版本整理了,都统一放在了这里, 方便大家下载: http://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图