how2j.cn

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



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



步骤 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  姿势不对,事倍功半! 点击查看做练习的正确姿势
如下是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浏览器。 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的 视频下载插件会影响播放,如 IDM 等,请关闭或者切换其他浏览器


答案-自定义字符串的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  姿势不对,事倍功半! 点击查看做练习的正确姿势
根据前面学习的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浏览器。 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的 视频下载插件会影响播放,如 IDM 等,请关闭或者切换其他浏览器


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  姿势不对,事倍功半! 点击查看做练习的正确姿势
重复前面的 练习-查找内容性能比较 ,不过不使用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浏览器。 如果装有迅雷,播放视频呈现直接下载状态,请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的 视频下载插件会影响播放,如 IDM 等,请关闭或者切换其他浏览器


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公众号,关注后实时获知最新的教程和优惠活动,谢谢。


问答区域    
2020-10-27 第一题答案
lx213




直接复制放到main函数下测试
                String [] str = new String[100];
		for (int i = 0; i < 100; i++) 
		{
			int length = (int)(Math.random()*9)+2;
			char [] c = new char[length];
			for (int j = 0; j < length; j++) 
			{
				c[j] = (char)(Math.random()*26+65);
			}
			System.out.println(c);
			str[i] = new String(c);
		}
		for (int i = 0; i < 100; i++) 
		{
			int hashcode = 0;
			for (int j = 0; j < str[i].length(); j++) hashcode += ((int)str[i].charAt(j));
			hashcode *= 23;
			hashcode%=2000;
			System.out.format("第%d个字符串是:%s,其hashcode是%d\n",i+1,str[i],hashcode);
		}

							





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





2020-10-01 三道题目详解及注释
兵长




可以直接运行测试
package collection;
import java.util.*;

/**
 * 1)自定义字符串的hashcode
 *   随机生成长度是2-10的不等的100个字符串,打印用本hashcode获取的值分别是多少
 * 2)自定义MyHashMap
 * 3)性能比较
 *   1. 不使用MyHashMap,直接使用for循环找出来,并统计花费的时间
 *   2. 借助MyHashMap,找出结果,并统计花费的时间
 */
public class HashCodeTest {
    public static void main(String[] args) {
        //输出100个字符的hashcode
        for (int i = 0; i < 100; i++) {
            char[] chars = new char[ranLen()];
            for (int j = 0; j < chars.length; j++) {
                chars[j] = ranCh();
            }
            String str = String.valueOf(chars);
            System.out.println(str + " 的hashcode:" + hashcode(str));
        }
        //性能测试
        MyHashMap myHashMap = new MyHashMap();
        ArrayList<Student> arrayList= new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 100000; i++) {
            int tmp = random.nextInt(8999) + 1000;
            Student student = new Student("student-" + tmp);
            arrayList.add(student);
            myHashMap.put(student.name,student);
        }
        System.out.println(selArr(arrayList));
        System.out.println(selMap(arrayList));
    }
    //array性能测试
    public static double selArr(ArrayList<Student> arrayList){
        long start = System.currentTimeMillis();
        for (int i = 0; i < arrayList.size(); i++) {
            if(arrayList.get(i).name.equals("student-5555")){
                System.out.println("找到student对象:" + arrayList.get(i).name);
            }
        }
        long end = System.currentTimeMillis();
        return (end-start)/1.0;
    }
    //map性能测试
    public static double selMap(ArrayList<Student> arrayList){
        MyHashMap myHashMap = new MyHashMap();
        for (int i = 0; i < arrayList.size(); i++) {
            myHashMap.put(arrayList.get(i).name,arrayList.get(i));
        }
        System.out.println(myHashMap.get("student-5555"));
        long start = System.currentTimeMillis();
        long end = System.currentTimeMillis();
        return (end-start)/1.0;
    }
    //随机生成的长度
    public static int ranLen(){
        Random random = new Random();
        return random.nextInt(8) + 2;
    }
    //随机生成一个字符
    public static char ranCh(){
        Random random = new Random();
        //假设字符是由大小写和数字构成
        char ch;
        //判断获取的是数字还是字母,数字概率是10/62,字母概率52/62
        if(random.nextInt(62) > 10){
            //判断大小写
            if(random.nextInt(2)%2 == 0){
                ch = (char)(random.nextInt(26) + 65);
            }
            else
                ch = (char)(random.nextInt(26) + 97);
        }else {
            ch = (char)(random.nextInt(10) + 48);
        }
        return ch;
    }
    public static int hashcode(String s){
        char[] chars = s.toCharArray();
        int hashcode = 0;
        //获取每一位字符
        for (int i = 0; i < s.length()-1; i++) {
            hashcode += chars[i];
        }
        hashcode = hashcode + chars[s.length()-1] * 23;
        if(hashcode >= 2000) hashcode = hashcode%2000;
        return hashcode;
    }
}
//自定义hashmap
class MyHashMap implements IHashMap {
    //根据题目要求,创建一个由LinkedList集合构成的数组,LinkedList里存放的是Entry键值对
    LinkedList<Entry>[] a;
    public MyHashMap() {
         a =  new LinkedList[2000];
    }
    //myhashmap使用put添加和hashmap略微不同,hashmap键不能重复,所以相同的的键无法加入。而myhashmap可以把相同的键加入到链表
    @Override
    public void put(String key, Object object) {
        if(a[hashcode(key)] == null){
            Entry entry = new Entry(key,object);
            a[hashcode(key)] = new LinkedList();
            a[hashcode(key)].add(entry);
        }
        else {
            Entry entry = new Entry(key,object);
            a[hashcode(key)].add(entry);
        }
    }
    @Override
    public Object get(String key) {
        int index = hashcode(key);
        if(a[index] == null) return null;
        else{
            //这里使用迭代器
            ListIterator<Entry> listIterator=a[index].listIterator();
            Entry entry;
            //使用LinkedList链表保存需要返回的值
            LinkedList<Entry> linkedList = new LinkedList<>();
            while (listIterator.hasNext()){
                if((entry = listIterator.next()).key.equals(key))
                    linkedList.add(entry);
            }
            return linkedList;
        }
    }
    //这个同上一个hascode方法
    public static int hashcode(String s){
        char[] chars = s.toCharArray();
        int hashcode = 0;
        //获取每一位字符
        for (int i = 0; i < s.length()-1; i++) {
            hashcode += chars[i];
        }
        hashcode = hashcode + chars[s.length()-1] * 23;
        if(hashcode >= 2000) hashcode = hashcode%2000;
        return hashcode;
    }
}
interface IHashMap {
    void put(String key,Object object);
    Object get(String key);
}
class Entry {
    public Entry(String key, Object value) {
        super();
        this.key = key;
        this.value = value;
    }
    public String key;
    public Object value;
    @Override
    public String toString() {
        return "[key=" + key + ", value=" + value + "]\n";
    }
}
class Student{
    String name;
    public Student(String name) {
        this.name = name;
    }
}

							


1 个答案

cs-yyds
答案时间:2021-01-13
import java.util.*; public class MyHashMap implements IHashMap { List[] list = new List[2000]; public static int hashcode(String str) { if(str.length() == 0) return 0; int sum = 0; for(int i=0; i<str.length(); i++) { sum = sum + (int)str.charAt(i); } sum = sum*23; if(sum < 0) return -sum; if(sum > 1999) return sum%2000; return sum; } @Override public void put(String key, Object object) { // TODO Auto-generated method stub if(list[hashcode(key)] == null) { LinkedList<Entry> ldl = new LinkedList<>(); ldl.add(new Entry(key,object)); list[hashcode(key)] = ldl; } else { list[hashcode(key)].add(new Entry(key,object)); } } @Override public Object get(String key) { // TODO Auto-generated method stub if(list[hashcode(key)] == null) return null; else { Entry et = null; LinkedList l = (LinkedList) list[hashcode(key)]; for(int i=0; i<l.size(); i++) { et = (Entry) l.get(i); if(et.key.equals(key)) return et.toString(); } return null; } } public static void main(String[] args) { MyHashMap mhm = new MyHashMap(); mhm.put("小小英雄", 123); mhm.put("进击的巨人", null); System.out.println(mhm.get("进击的巨人")); System.out.println(mhm.get("小小英雄")); System.out.println(mhm.get("sad")); } }



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





2020-08-06 打卡(2 3题)
2020-07-08 这里面难度较高
2020-04-11 查找性能结果不对


提问太多,页面渲染太慢,为了加快渲染速度,本页最多只显示几条提问。还有 35 条以前的提问,请 点击查看

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

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

上传截图