散列与散列码

总结个人关于雷达样式的见解(脉内脉间调制) 概述 雷达有各种各样的脉内脉间调制样式,对于雷达的设计者来说,不外乎三个目的: 1、增加雷达性能,如提高测距精度,增大侦察距离等; 2、雷达的工作机制决定雷达必须采用此种样式的调制,如有些SAR雷达为保证径向测距精度,需要使用脉内宽带调制信号; 3、降低雷达被电子战装备截获的概率,也就是LPI设计。 对于雷达对抗方,则只会观察到信号存在脉内及脉间的调制。对于一般的雷达信号,通常只采用脉内调制,脉间频率调制,脉间PRI调制。 脉间调制类型 1、PD雷达的脉间特征 雷达进行脉间调制的主要是PRI.. 阅读详情

Demo:
按照你的想象,我们应该是可以查出来Groudhog gh = ghog.newInstance(3);这个key的,但是没查到

package cn.partner4java.hashcode;

/**
 * 每个Groudhog被给予一个标识数字
 * @author partner4java
 *
 */
public class Groudhog {
	protected int number;
	public Groudhog(int number) {
		this.number = number;
	}
	@Override
	public String toString() {
		return "Groudhog #" + number;
	}
}


package cn.partner4java.hashcode;

import java.util.Random;

/**
 * Predition类包含一个boolean值和一个toString方法。
 * boolean用java.util.randrom()来初始化
 * @author partner4java
 *
 */
public class Prediction {
	private static Random random = new Random(47);
	private boolean shadow = random.nextDouble() > 0.5;
	@Override
	public String toString() {
		if(shadow){
			return "Six more weeks of Winter!";
		}else{
			return "Early Spring";
		}
	}
}


package cn.partner4java.hashcode;

import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

/**
 * detectSpring方法使用反射机制来实例化及使用Groundhog类或任何从Groundhog派生来的类。
 * @author partner4java
 *
 */
public class SpringDetector {
	public static <T extends Groudhog> void detectSpring(Class<T> type) throws Exception{
		Constructor<T> ghog = type.getConstructor(int.class);
		Map<Groudhog, Prediction> map = new HashMap<Groudhog, Prediction>();
		for(int i=0;i<10;i++){
			map.put(ghog.newInstance(i), new Prediction());
		}
		System.out.println("map = " + map);
		Groudhog gh = ghog.newInstance(3);
		System.out.println("Looking up prediction for " + gh);
		if(map.containsKey(gh)){
			System.out.println(map.get(gh));
		}else{
			System.out.println("key not found: " + gh);
		}
	}
	
	public static void main(String[] args) throws Exception {
		detectSpring(Groudhog.class);
	}
}



问题出在Groundhog自动的继承自基类Object,所以这里使用Object的hashCode方法生成散列码,而他默认是使用对象的地址计算散列码。
因此两个Groundhog(3)的散列码不同。


但是,你覆盖hashCode的同时也必须覆盖equals()方法,他也是Object的一部分。
HashMap使用equals()判断当前的键是否与表中存在的键相同。




正确的equals方法必须满足下列5个条件:
1、自反性(reflexive):对于任何非null的引用值x,x.equals(x)必须返回true。
如果违背,当你把该类的实例添加到集合(collection)中,然后该集合的contains会告诉你,没有包含你刚刚添加的实例。


2、对称性(symmetric):对于任何非null的引用值x和y,当且仅当y.equals(x)返回true时,x.equals(y)必须返回true。
一个实例对比不区分了大小写,但是,反过来对比是区分的,就导致了不对称。


3、传递性(transitive):对于任何非null的引用值x、y和z,如果x.equals(y)返回true,并且y.equals(z)也返回true,那么x.equals(z)也必须返回true。
子类增加的信息会影响到equals的比较结果。 


4、一致性(consistent):对于任何非null的引用值x和y,只要equals的比较操作在对象中所用的信息没有被修改,多次调用x.equals(y)就会一致的返回true,或者一致的返回false。
都不要是equals方法依赖于不可靠的资源。


5、非空性(Non-nullity):对于任何非null的引用值x,x.equals(null)必须返回false。 




默认的equals方法是比较的内存地址。
为Groundhog添加hashCode和equals方法:

package cn.partner4java.hashcode;

/**
 * 每个Groudhog被给予一个标识数字
 * @author partner4java
 *
 */
public class Groudhog {
	protected int number;
	public Groudhog(int number) {
		this.number = number;
	}
	@Override
	public String toString() {
		return "Groudhog #" + number;
	}
	
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + number;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Groudhog other = (Groudhog) obj;
		if (number != other.number)
			return false;
		return true;
	}
	
	
}

现在就可以查找到了。
参考:
http://blog.youkuaiyun.com/partner4java/article/details/7066349
http://blog.youkuaiyun.com/partner4java/article/details/7067919


------------------




理解hashCode()
使用散列的目的在于:想要使用一个对象来查找另外一个对象。不过使用TreeMap或者你自己使用Map也可以达到此目的。


Demo:

package cn.partner4java.hashcode;

import java.util.Map.Entry;

/**
 * Map.entrySet()方法必须产生一个Map.Entry<K, V>对象集。但是,Map.Entry是一个接口,用来描述依赖于实现的结构,因此如果你想要创建自己的Map类型。
 * @author partner4java
 *
 * @param <K>
 * @param <V>
 */
public class MapEntry<K, V> implements Entry<K, V> {
	private K key;
	private V value;
	
	public MapEntry(K key, V value) {
		super();
		this.key = key;
		this.value = value;
	}
	public K getKey() {
		return key;
	}
//	public void setKey(K key) {
//		this.key = key;
//	}
	public V getValue() {
		return value;
	}
	public V setValue(V v) {
		V result = value;
		value = v;
		return result;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((key == null) ? 0 : key.hashCode());
		result = prime * result + ((value == null) ? 0 : value.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		MapEntry other = (MapEntry) obj;
		if (key == null) {
			if (other.key != null)
				return false;
		} else if (!key.equals(other.key))
			return false;
		if (value == null) {
			if (other.value != null)
				return false;
		} else if (!value.equals(other.value))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "MapEntry [key=" + key + ", value=" + value + "]";
	}
	
	
	
}



package cn.partner4java.hashcode;

import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.mindview.util.Countries;

/**
 * 与散列相反,用一对ArrayList实现了一个Map。
 * put()方法只是将键与值放入相应的ArrayList。为了与Map接口保持一致,他必须返回旧的键,或者在没有任何旧键的情况下返回null。
 * 如果键存在,他将被用来查找表示他在keys列表中的位置数值型索引,并且这个数字被用作索引来产生与values列表相关联的值。
 * @author partner4java
 *
 * @param <K>
 * @param <V>
 */
public class SlowMap<K, V> extends AbstractMap<K, V> {
	private List<K> keys = new ArrayList<K>();
	private List<V> values = new ArrayList<V>();
	
	public V get(Object key){
		if(!keys.contains(key)){
			return null;
		}
		return values.get(keys.indexOf(key));
	}
	
	public V put(K key,V value){
		V oldValue = get(key); //The old value or null
		if(!keys.contains(key)){
			keys.add(key);
			values.add(value);
		}else{
			values.set(keys.indexOf(key), value);
		}
		return oldValue;
	}
	
	@Override
	public Set<Map.Entry<K, V>> entrySet() {
		Set<Map.Entry<K, V>> set = new HashSet<Map.Entry<K,V>>();
		Iterator<K> ki = keys.iterator();
		Iterator<V> vi = values.iterator();
		while(ki.hasNext()){
			set.add(new MapEntry<K, V>(ki.next(),vi.next()));
		}
		return set;
	}

	public static void main(String[] args) {
		SlowMap<String, String> m = new SlowMap<String, String>();
		m.putAll(Countries.capitals(15));
		System.out.println(m);
		System.out.println(m.get("BENIN"));
		System.out.println(m.entrySet());
	}
}

----------------






为速度而散列:
(前提宗旨是使用数组,因为比线程查找要快)
散列的价值在于速度:散列是的查询得以快速的进行。由于瓶颈位于键的查询速度,因此解决方案之一就是保持键的排序状态,然后使用Collections.binarySearch()进行查询。


散列则更进一步,他讲健保持在某一处,以便能够很快的查找。他使用数组保持了键生成的一个数字,将其作为数组的下标。这个数组就是散列码。


为解决数组容量被固定的问题,不同的键可以产生相同的下标。


于是查询一个值的过程首先就是计算散列码,然后使用散列码查询数组。一般,如果散列码相同冲突,由外部链接处理:数组并不直接保持值,而是保持值的list。然后对list的值使用equals方法进行线性的查询。这部分的查询会比较慢,但是如果散列函数好的话,数组的每个位置的值会很少。因此,不是查整个list,而是立刻跳到数组的某个位置。这便是HashMap会比较快的原因。


Demo:

package cn.partner4java.hashcode;

import java.util.AbstractMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

import net.mindview.util.Countries;

public class SimpleHashMap<K, V> extends AbstractMap<K, V> {
	// Choose a prime number for the hash table
	// size,to achieve a uniform distribution
	static final int SIZE = 997;
	// You can't have a physical array of generics,
	// but you can upcast to one;
	@SuppressWarnings("unchecked")
	LinkedList<MapEntry<K, V>>[] buckets = new LinkedList[SIZE];

	@Override
	public V get(Object key) {
		int index = Math.abs(key.hashCode()) % SIZE;
		if (buckets[index] == null)
			return null;
		for (MapEntry<K, V> iPair : buckets[index]) {
			if (iPair.getKey().equals(key)) {
				return iPair.getValue();
			}
		}
		return null;
	}

	@Override
	public V put(K key, V value) {
		V oldValue = null;
		int index = Math.abs(key.hashCode()) % SIZE;
		if (buckets[index] == null)
			buckets[index] = new LinkedList<MapEntry<K, V>>();
		LinkedList<MapEntry<K, V>> bucket = buckets[index];
		MapEntry<K, V> pair = new MapEntry<K, V>(key, value);
		boolean found = false;
		ListIterator<MapEntry<K, V>> it = bucket.listIterator();
		while (it.hasNext()) {
			MapEntry<K, V> iPair = it.next();
			if (iPair.getKey().equals(key)) {
				oldValue = iPair.getValue();
				it.set(pair); // Replace old with new
				found = true;
				break;
			}
		}
		if (!found)
			buckets[index].add(pair);
		return oldValue;
	}

	@Override
	public Set<Map.Entry<K, V>> entrySet() {
		Set<Map.Entry<K, V>> set = new HashSet<Map.Entry<K, V>>();
		for (LinkedList<MapEntry<K, V>> bucket : buckets) {
			if (bucket == null)
				continue;
			for (MapEntry<K, V> mpair : bucket)
				set.add(mpair);
		}
		return set;
	}

	public static void main(String[] args) {
		SimpleHashMap<String, String> m = new SimpleHashMap<String, String>();
		m.putAll(Countries.capitals(25));
		System.out.println(m);
		System.out.println(m.get("ERITREA"));
		System.out.println(m.entrySet());
	}
}






---------------




覆盖hashCode()


每个覆盖了equals方法的类中,也必须覆盖hashCode方法。 
如果不这样的话,就会违反Object.hashCode的通用约定,从而导致该类无法结合所有基于散列的集合一起正常运作,这样的集合包括HashMap、HashSet和Hashtable。


在引用程序的执行期间,只要对象的equals方法的比较操作所用到的信息没有被修改,那么对这同一个对象调用多次,hashCode方法都必须始终如一的返回同一个整数。在一个应用程序的多次执行过程中,每次执行所返回的整数可以不一致。 
如果连个对象根绝equals方法比较是相等的,那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。 
如果两个对象根据equals方法比较是不相等的,那么调用这两个对象中任意一个对象的hashCode方法,则不一定要产生不同的整数结果。但是程序员应该知道,给不相等的对象产生截然不同的整数结果,有可能提高散列表(hash table)的性能。(比如,当你一个entity只根据id比较是否相等,但是在没实例化之前,没有id数值,那么默认的equals返回false,但是hashCode返回的值却相等。) 


STM32 IIC温湿度传感器(STH45)实验 精度 ΔRH = ±1.0 %RH, ΔT = ±0.1 °C• 平均电流:0.4 μA,空闲电流:80 nA• I2C FM、CRC 校验和、乘法。I2C 地址。• 专利保护选项 [1]、PTFE 膜和可拆卸保护盖• 工作范围:0 …100 %相对湿度,−40…125 摄氏度• 在冷凝环境中功能齐全• 动力加热器,真正的NIST可追溯性• JEDEC JESD47 认证 • 符合 ISO 17025 : 2017 的传感器专用校准证书,3 点温度校准。 阅读详情

相关推荐

深入解析DDR5 SDRAM中的CA训练模式(CATM):原理与实现

本文深入解析DDR5 SDRAM中的CA训练模式(CATM),详细探讨其工作原理与实现方法。通过分析JESD79-5标准,揭示CATM在时序校准、信号质量优化和系统稳定性方面的核心价值,并提供硬件设计考量和系统级调试技巧,帮助工程师解决高速内存系统中的信号完整性问题。

weixin_29235923的博客 387

散列、散列码、hashCode()

散列、散列码、hashCode()

Marlboro 1641

ArcMap对遥感图像进行语义分割标注

使用arcmap对遥感图像进行语义分割标注

qq_41708916的博客 4056

简析散列和散列码

在学习散列集集或者图(Map)时,我们也许对这两个方法并不陌生:equals()和hashCode();添加到散列集中的对象必须以正确地方式实现hashCode()方法才能确保集合中不出现重复的值。最近在阅读《Thinking in Java》这本书时,里面有对其系统地介绍,现将其总结一下:初步了解散列码在开发中,我们对于HashMap的使用并不陌生,但有时却也会犯错。我们先看一个例子://定义人这

QAQ 3898

【Azure 架构师学习笔记】- Azure Databricks (1) - 环境搭建

Databricks 已经成为了数据科学的必备工具,今时今日你已经很难抛开它来谈大数据,它常用于做复杂的ETL中的T, 数据分析,数据挖掘等,特别适用于做数据建模,机器学习等。那么顺应时代,现在也来看看这个工具的内容。首先要有一个环境,基于Azure 的Databricks简称ADB。托管在Azure 上的Databricks已经被Azure进行了很大的优化, 在搭建时只需要简单的几步即可拥有一个环境,不过要提醒一句ADB的集群并不便宜,用完马上删掉或停止, 否则一晚过百美金就会烧掉。

MVP黄钊吉(發糞塗牆) 2299

ESP32 WiFi自平衡小车硬件与PID控制实战

自平衡小车是典型的嵌入式实时反馈控制系统,其核心依赖姿态感知(如MPU6050)、电机驱动(如L298N)与闭环控制算法(如PID)的协同。系统通过IMU采集俯仰角,经互补滤波融合处理,再由PID控制器实时计算PWM输出,驱动直流电机产生恢复力矩;WiFi模块(ESP32内置)则提供远程遥控接口,实现AP模式下的Web指令交互。该架构兼具硬实时性(毫秒级采样与响应)与软实时性(HTTP服务),广泛应用于机器人教学、智能小车开发及边缘控制原型验证。本文围绕ESP32平台,详解传感器接口、驱动电路设计、PID抗

weixin_42509513的博客 394

Java基础-理解散列与散列码

1.从HashMap说起我们知道Map以键值对的形式来存储数据。有一点值得说明的是,如果要使用我们自己的类作为键,我们必须同时重写hashCode() 和 equals()两个方法。HashMap使用equals方法来判断当前的键是否与表中的键相同。equals()方法需要满足以下5个条件 自反性 x.equals(x) 一定返回true 对称性 x.equals(y)返回true,则y.equa

_StriveG的专栏 1万+

树莓派4B系统安装及SSH远程控制(简单易操作)

​自从2022年4月树莓派官网更新了RaspberryPiImager版本v1.7.2后,便不再支持自行建立ssh文件,并用默认用户名pi和密码raspberry的方式进行远程控制(亲测不行,输密码时一直access denied)。但是该版本软件提供了烧录系统前设置ssh用户及密码功能。本文记录了系统安装和SSH远程操作步骤。........................

机械人的代码路 5792

java-散列和散列码

散列将键保存在某处,以便能够很快找到。存储一组元素最快的数据结构是数组,所以使用它来表示键的信息。 数组并不保存键本身,而是通过键对象生成一个数字,将其作为数组的下标,这个数字就是散列码。 冲突有外部链接处理,数组并不直接保存值,而是保存值得list。然后对list中的值使用equals()方法进行线性的查询。(这部分的查询会比较慢)

4395

PCIe Crosslink

PCIe Crosslink(交叉连接)是一种特殊的PCIe链路连接方式,允许两个PCIe设备(通常是Root Complex或Endpoint)是指两个PCIe设备(如两个CPU、两个FPGA或两个GPU)通过PCIe链路直接连接,形成点对点(P2P)通信通道。:两个Intel/AMD CPU通过PCIe Crosslink直接通信(替代UPI/Infinity Fabric)。:主板需提供PCIe Crosslink连接(如特定插槽支持x16/x8 Crosslink)。

zly8865372的博客 1639

网络分析工具Wireshark系列专栏:01-专栏导读

随着人工智能技术的普及,越来越多的博主开始利用AI进行内容创作,导致优快云等平台上充斥着大量低质量的洗稿文章,严重影响了技术软文的质量和可信度。为了应对这一现象,提升技术内容的质量,瑞哥决定推出系列技术专栏,为大家带来系统、深入且高质量的技术学习资源。这些专栏将帮助读者从入门到精通,特别适合习惯通过文档学习的技术爱好者。作为首个专栏,我们将聚焦于Wireshark——一款广受欢迎的网络协议分析工具。根据优快云后台的反馈,许多读者表示Wireshark是他们欠缺的一项技能。因此,本专栏将通过精心设计的课程

网络技术联盟站 360

java 一组散列码_【ThinkingInJava】51、散列与散列码

/*** 书本:《Thinking In Java》* 功能:散列与散列码* 文件:Groundhog.java* 时间:2015年5月3日09:42:54* 作者:cutter_point*/package Lesson17Containers;public class Groundhog{protected int number;//保护类型,继承之后还是保护类型public Groundho...

weixin_42523670的博客 172

G120变频器抱闸逻辑在提升机上应用

一、前言: 对于提升机、起重机、堆垛机、升降机等提升机构,负载为位能性负载,在设备启动和停止阶段,由于重物作用,可能会出现“溜车”现象、控制变频器与电机抱闸时许可以解决此问题 使用具有矢量控制功能的变频器 二、参数设置 抱闸控制时序: 启动: 1、变频器接收到启动命令时-----输出电流对电机进行励磁,经过P346电机励磁时间(==丹佛斯 设置启动电流延时0.5S)------达到一定的转矩 2、变频器输出开抱闸命令,经过P1216延时打开抱闸时间(==PLC延时控制打开抱闸) 注意:抱闸

fenglingxicao的博客 1万+

散列码

散列码 散列码是由对象导出的一个整型值,没有规律,两个不同的对象调用hashCode()基本上不会相同,而字符串的散列码是由内容导出的。 String s = "hello"; String t = "hello"; System.out.println(s.hashCode()); System.out.println(t.hashCode()); //99162322 //99162322...

weixin_43951032的博客 377

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

java中散列码和16进制_【ThinkingInJava】51、散列与散列码

/*** 书本:《Thinking In Java》* 功能:散列与散列码* 文件:Groundhog.java* 时间:2015年5月3日09:42:54* 作者:cutter_point*/package Lesson17Containers;public class Groundhog{protected int number;//保护类型,继承之后还是保护类型public Groundho...

weixin_42511315的博客 149

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

【ThinkingInJava】51、散列与散列码

/** * 书本:《Thinking In Java》 * 功能:散列与散列码 * 文件:Groundhog.java * 时间:2015年5月3日09:42:54 * 作者:cutter_point */ package Lesson17Containers; public class Groundhog { protected int number; //保护类型,继承之后还是保护类型

cutter_point的专栏 774

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

散列(Hash)和散列码(HashCode)

概念 散列:散列也叫散列函数,是一种可以将任意长度的输入转换为固定长度输出的算法,因此不同的输入可能产生相同的输出。 散列码:散列码就是按照散列函数生成的结果。 散列在编程语言中的应用 散列可以将对象信息提取出摘要,然后产生固定长度的结果,我们利用这个结果跟对象关联起来就能达到快速查找对象的目的。那么,在众多的对象查找方法里,为什么要使用散列?因为快,就相当于抽象的Map直接通过key(散列结果)...

chenyl 3283

散列码,HashCode的理解与应用

转自http://bbs.youkuaiyun.com/topics/90176996 maquan的回答 我的理解是:“散列码”就是用来把一堆对象散到各自的队列里去的一种标识码。 举个形象一点的例子,一年有 365 天,从 1 编号到 365,下面我定义一种编码方法,每个人按照他生日那天的编号作为他的标识码,这样,一群人每个人就会有一个标识码。 这个标识码有什么用呢?好,下面我说,请所有单

Fred 2609

Java - 散列码

散列与散列码正确的equals()方法必须满足以下5个条件: 1. 自反性.对任意x,x.equals(x)一定返回true. 2. 对称性.对任意x/y,如果y.equals(x)返回true,则x.equals(y)也返回true 3. 传递性.对任意x/y/z,如果有x.equals(y)返回true,y.equals(z)返回true,则x.equals(z)一定返回true. 4.

biezhihua的专栏 1537

Java高级系列——散列与散列码

使用散列的目的:想要使用一个对象查找另一个对象。 散列的价值:散列的价值在于速度,散列使得查询得以快速进行。 设计hashCode()时最重要的因素:无论何时,对同一个对象调用hashCode()都会产生同样的值。如果将一个对象用put()添加进HashMap时产生一个hashCode()值,而用get()取出时却产生了另外一个hashCode()值,那么就无法重新取得该对象了。 想要使ha...

Ron.Zheng 2140

散列码的计算

        在实现词典这种数据结构时,我们需要根据查找键来查找所对应的值,这就要求我们首先要能计算出查找键的的散列码,然后再将散列码压缩为散列表的索引。          查找键可以是一个类类型,也可以是字符串,也可以是基本类型。对于不同的类型有不同 的计算方法,下面做一下总结:           一   类类型的散列码的计算                JAVA的基类Object类中有一...

信心,恒心,野心,爱心兼具者,可谓准成功人士! 300

Java散列和散列码

  散列的价值在于速度:散列使得查询得以快速进行,由于瓶颈位于键的查询速度,因此解决方案之一就是保持键的排序状态,然后使用Collections.binarySearch()进行查询。   散列则更进一步,它将键保存在某处,以便能够快速找到,存储一组元素最快的数据结构是数组,所以使用它来表示键的信息(键的信息,而不是键本身),但是因为数组不能调整容量,因此就有一个问题:我们希望在Map中保存数量不确定的值,但是如果键的数量被数组的容量限制了,该怎么办呢?   答案就是:数组并不保存键本身,而是通过键对象生成

qq_41133155的博客 341

hashmap: 散列码和数组索引

看了这篇文章, 可以了解 散列码和数组索引还不是一回事,  在hashmap中hashcode要先经过运算得到一个h,然后h&(length-1),这样才得到数组索引.   什么是hashcode      分析HashMap之前先介绍下什么Hashcode(散列码)。它是一个int,每个对象都会有一个hashcode,它在内存的存放位置是放在对象的头部(对象头部存放的信息有hashcode

lksodit_yiyi的专栏 2425

Java散列和散列码的实现

转自:https://blog.youkuaiyun.com/al_assad/article/details/52989525 散列和散列码 ※正确的equals方法应该满足的的条件: ①自反性:x.equals(x) 一定返回true; ②对称性:y.euqlas(x)为true,那么x.equals(y)一定为true; ③传递性:x.equals(y)为true,y.euqlas(z)...

weixin_33974433的博客 250

如何生成散列码

1)给int变量result赋予某个非零值常量,例如17。 2)为对象内每个有意义的域f(即每个可以做equals()操作的域)计算出一个散列码c: 域类型                          计算 boolean                         c=(f?0:1) . . . . . Object,其equals()调用这个域的equals()  ...

weixin_30729609的博客 188
上一篇: 注解
下一篇: 泛型
partner4java
博客等级 码龄17年 481粉丝 183原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值