iOS中的哈希表

哈希表也叫散列表，是根据键值(Key value)而直接进行访问的数据结构。也就是说，它通过把键(Key)映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做哈希函数，映射函数得出的值叫哈希值或哈希码，存放记录的数组叫做哈希表。哈希表中存放数据占总空间比例叫做装填因子（负载因子）。

哈希函数的设计要达到输出值的平均分布化，这样能尽可能降低哈希冲突的概率。

一般情况下，哈希函数中输入值与输出值具有 N对1 关系。

哈希函数具有的特点：如果两个哈希码不同，则它们的键(Key)也一定不同。

该特点常用于优化比较两个对象是否相同，先判断hash码是否相同，若hash码不同则不需要进行对象比较。

哈希表优点：查找效率高，插入删除和查找时间复杂度为O(1)。

哈希表缺点：占用空间大，需要预留一定空间，否则哈希冲突概率会很大。哈希表无法记录插入顺序。

哈希函数因为会N对1的关系，会触发哈希冲突。哈希冲突常见解决方式有有以下几种：

1 开放寻址法

线性探测（偏移1，2，3）

可能会导致数据堆积一起，降低插入删除和查找效率。

二次方探测（偏移11，22，33）

相比线性探测不容易造成数据堆积，但当装填因子比较大时，可能会造成一次查询/插入中，同一位置多次被探测。

2 拉链法

使用数组+链表解决哈希冲突问题。

开放寻址法缺点：

开放寻址法的缺点是在删除元素时，不能真的删除，否则会引起查找失败。需要在删除元素位置做个标记，代表该索引位置可以插入，但是搜索路过时不能中断搜索。

另一方面，开放寻址法因为在冲突时会占用其它哈希索引空间，所以扩容时装填因子不能太大。

哈希表扩容与缩容

当装填因子过大，会增大哈希冲突概率，需要对哈希表进行扩容，因此哈希表一般使用二级指针实现(iOS底层使用DisguisedPtr<void >）。扩容时需要对所有数据进行重新映射（重哈希），一般每次空间2。

当装填因子太小，且空间占用比较大，比如：if (装填因子 < 01 && num >1024) {缩容}。

哈希算法本质是一类安全性较高的哈希函数。Hash算法还具有一个特点，就是很难找到逆向规律。

哈希算法常用于密码安全领域，哈希算法中输入值与输出值具有 N对1 关系，常见的哈希算法包括MD5，SHA，CRC16，CRC32。

SideTables是个全局变量，是StripedMap（哈希表）类型。

StripedMap重载了[]，可通过下标的方式快速存取。

StripedMap事实上不是个常规的哈希表，我认为它可以叫做只读哈希表。它在创建之初就会以模版类型初始化满所有存储空间，且不支持修改和扩容。因此，模版类型传递指针是没有意义的。一般模版都设置为结构体，后续 *** 作针对该结构体改值。

SideTables的哈希Key是对象地址addr，哈希函数是((addr >>4) ^ (addr >>9)) %StripeCount，Value是SideTable结构体。因此，SideTables存储着对象地址与SideTable的 N-1 关系。这样可以把对象信息分散到不同SideTable中，提升查找效率。

每个SideTable中存储一堆对象的弱引用表和引用计数表。

weak_table_t的哈希Key是对象地址，哈希函数如下：

Value是weak_entry_t。weak_table_t可以通过对象指针快速找到对象存储的weak_entry_t。

weak_table_t可进行扩容与缩容。

当出现哈希冲突时，与weak_table_t配套的函数使用线性探测法查找。

每个weak_table_t中存储一堆对象的弱引用表。

weak_entry_t只有当装载数据超过一定长度才会启用哈希表存储功能，out_of_line()返回是否启用哈希表。weak_entry_t的哈希Key是弱指针地址，value也是弱指针地址。哈希函数与weak_table_t相同。

weak_entry_t可进行扩容，不会进行缩容。

当出现哈希冲突时，与weak_entry_t配套的函数使用线性探测法查找。

每个weak_entry_t存储指向一个对象的所有弱指针地址（二级指针）。

RefcountMap本质是DenseMap类按照指定模版typedef的类型。

RefcountMap的哈希Key是对象地址，Value是引用计数。

当value为0时，RefcountMap会自动清除这条记录。

当出现哈希冲突时，RefcountMap使用二次方探测法查找。

每个RefcountMap中存储一堆对象的引用计数。

sDataLists是存储所有@synchronized锁的全局哈希表，key是@synchronized的参数。

PropertyLocks是存储所有atomic锁的全局哈希表，key是属性生成的成员变量地址。

类对象的方法缓存cache_t使用哈希表存储bucket_t（sel+imp)，使用逆序线性探测（Index-1)解决哈希冲突。

cache_t扩容时会将所有方法缓存清空。

static objc::ExplicitInitDenseSet<const char > namedSelectors;

namedSelectors是个全局变量，存储所有的方法名SEL，内部结构是哈希表DenseMap。

typedef DenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap> AssociationsHashMap;

AssociationsHashMap是AssociationsManager中存储所有关联对象的哈希表，内部结构是DenseMap。

NSObject默认的hash方法是对象地址，即默认没有做优化。

还有个方法isEqual:方法，NSObject默认实现返回该对象与参数对象指针地址是否相同。

hash方法的本质是该对象的哈希函数，需要子类去实现。hash方法主要有两个作用，这两个作用在NSDictionary和NSSet中体现出来。

1 与isEqual:配合，优化比较

先调用hash方法进行比较，若值相同才调用isEqualTo:进行比较。这依赖于hash的 N-1 关系。

从CF源码中可以找到CFString的源码，即可以看到NSString内部重写的hash方法。

这句话的大意是：这个字符串的大小如果小于等于96，则保证哈希的安全；如果大小大于96，则会大幅度增加哈希冲突的概率。

2 与哈希表配合，hash方法对应哈希表的哈希函数，但返回值需要经过转换对应存储索引（一般通过取余）。此时hash方法的设计就非常重要，应做到输出哈希码的平均分散化，否则会导致数据堆叠，增大哈希冲突概率。

常见的NSDictionary和NSSet内部就是哈希表，NSDictionary会使用Key作为哈希表的Key，NSSet使用元素作为Key。它们会对Key对象调用hash方法获得初步的哈希码，然后经过转变成为存储区域的索引（下标）。

NSDictionary和NSSet因为都使用哈希表存储，因此存储元素都是无序的。

NSDictionary和NSSet在插入新元素时具体步骤如下：

1equals()的所属以及内部原理（即Object中equals方法的实现原理）

说起equals方法，我们都知道是超类Object中的一个基本方法，用于检测一个对象是否与另外一个对象相等。而在Object类中这个方法实际上是判断两个对象是否具有相同的引用，如果有，它们就一定相等。其源码如下：

public boolean equals(Object obj) { return (this == obj); }

实际上我们知道所有的对象都拥有标识(内存地址)和状态(数据)，同时“==”比较两个对象的的内存地址，所以说 Object 的 equals() 方法是比较两个对象的内存地址是否相等，即若 object1equals(object2) 为 true，则表示 equals1 和 equals2 实际上是引用同一个对象。

2equals()与‘==’的区别

或许这是我们面试时更容易碰到的问题”equals方法与‘==’运算符有什么区别？“，并且常常我们都会胸有成竹地回答：“equals比较的是对象的内容，而‘==’比较的是对象的地址。”。但是从前面我们可以知道equals方法在Object中的实现也是间接使用了‘==’运算符进行比较的，所以从严格意义上来说，我们前面的回答并不完全正确。我们先来看一段代码并运行再来讨论这个问题。

package comzejiantest;

public class Car {

private int batch;

public Car(int batch) {

thisbatch = batch;

}

public static void main(String[] args) {

Car c1 = new Car(1);

Car c2 = new Car(1);

Systemoutprintln(c1equals(c2));

Systemoutprintln(c1 == c2);

}

}

运行结果：

false

false

分析：对于‘==’运算符比较两个Car对象，返回了false，这点我们很容易明白，毕竟它们比较的是内存地址，而c1与c2是两个不同的对象，所以c1与c2的内存地址自然也不一样。现在的问题是，我们希望生产的两辆的批次（batch）相同的情况下就认为这两辆车相等，但是运行的结果是尽管c1与c2的批次相同，但equals的结果却反回了false。当然对于equals返回了false，我们也是心知肚明的，因为equal来自Object超类，访问修饰符为public，而我们并没有重写equal方法，故调用的必然是Object超类的原始方equals方法，根据前面分析我们也知道该原始equal方法内部实现使用的是'=='运算符，所以返回了false。因此为了达到我们的期望值，我们必须重写Car的equal方法，让其比较的是对象的批次（即对象的内容），而不是比较内存地址，于是修改如下：

@Override

public boolean equals(Object obj) {

if (obj instanceof Car) {

Car c = (Car) obj;

return batch == cbatch;

}

return false;

}

使用instanceof来判断引用obj所指向的对象的类型，如果obj是Car类对象，就可以将其强制转为Car对象，然后比较两辆Car的批次，相等返回true，否则返回false。当然如果obj不是 Car对象，自然也得返回false。我们再次运行：

true

false

嗯，达到我们预期的结果了。因为前面的面试题我们应该这样回答更佳

总结：默认情况下也就是从超类Object继承而来的equals方法与‘==’是完全等价的，比较的都是对象的内存地址，但我们可以重写equals方法，使其按照我们的需求的方式进行比较，如String类重写了equals方法，使其比较的是字符的序列，而不再是内存地址。

3equals()的重写规则

前面我们已经知道如何去重写equals方法来实现我们自己的需求了，但是我们在重写equals方法时，还是需要注意如下几点规则的。

自反性。对于任何非null的引用值x，xequals(x)应返回true。

对称性。对于任何非null的引用值x与y，当且仅当：yequals(x)返回true时，xequals(y)才返回true。

传递性。对于任何非null的引用值x、y与z，如果yequals(x)返回true，yequals(z)返回true，那么xequals(z)也应返回true。

一致性。对于任何非null的引用值x与y，假设对象上equals比较中的信息没有被修改，则多次调用xequals(y)始终返回true或者始终返回false。

对于任何非空引用值x，xequal(null)应返回false。

当然在通常情况下，如果只是进行同一个类两个对象的相等比较，一般都可以满足以上5点要求，下面我们来看前面写的一个例子。

package comzejiantest;

public class Car {

private int batch;

public Car(int batch) {

thisbatch = batch;

}

public static void main(String[] args) {

Car c1 = new Car(1);

Car c2 = new Car(1);

Car c3 = new Car(1);

Systemoutprintln("自反性->c1equals(c1)：" + c1equals(c1));

Systemoutprintln("对称性：");

Systemoutprintln(c1equals(c2));

Systemoutprintln(c2equals(c1));

Systemoutprintln("传递性：");

Systemoutprintln(c1equals(c2));

Systemoutprintln(c2equals(c3));

Systemoutprintln(c1equals(c3));

Systemoutprintln("一致性：");

for (int i = 0; i < 50; i++) {

if (c1equals(c2) != c1equals(c2)) {

Systemoutprintln("equals方法没有遵守一致性！");

break;

}

}

Systemoutprintln("equals方法遵守一致性！");

Systemoutprintln("与null比较：");

Systemoutprintln(c1equals(null));

}

@Override

public boolean equals(Object obj) {

if (obj instanceof Car) {

Car c = (Car) obj;

return batch == cbatch;

}

return false;

}

}

运行结果：

自反性->c1equals(c1)：true

对称性：

true

true

传递性：

true

true

true

一致性：

equals方法遵守一致性！

与null比较：

false

由运行结果我们可以看出equals方法在同一个类的两个对象间的比较还是相当容易理解的。但是如果是子类与父类混合比较，那么情况就不太简单了。下面我们来看看另一个例子，首先，我们先创建一个新类BigCar，继承于Car,然后进行子类与父类间的比较。

package comzejiantest;

public class BigCar extends Car {

int count;

public BigCar(int batch, int count) {

super(batch);

thiscount = count;

}

@Override

public boolean equals(Object obj) {

if (obj instanceof BigCar) {

BigCar bc = (BigCar) obj;

return superequals(bc) && count == bccount;

}

return false;

}

public static void main(String[] args) {

Car c = new Car(1);

BigCar bc = new BigCar(1, 20);

Systemoutprintln(cequals(bc));

Systemoutprintln(bcequals(c));

}

}

运行结果：

true

false

对于这样的结果，自然是我们意料之中的啦。因为BigCar类型肯定是属于Car类型，所以cequals(bc)肯定为true，对于bcequals(c)返回false，是因为Car类型并不一定是BigCar类型（Car类还可以有其他子类）。嗯，确实是这样。但如果有这样一个需求，只要BigCar和Car的生产批次一样，我们就认为它们两个是相当的，在这样一种需求的情况下，父类（Car）与子类（BigCar）的混合比较就不符合equals方法对称性特性了。很明显一个返回true，一个返回了false，根据对称性的特性，此时两次比较都应该返回true才对。那么该如何修改才能符合对称性呢？其实造成不符合对称性特性的原因很明显，那就是因为Car类型并不一定是BigCar类型（Car类还可以有其他子类），在这样的情况下(Car instanceof BigCar)永远返回false，因此，我们不应该直接返回false，而应该继续使用父类的equals方法进行比较才行（因为我们的需求是批次相同，两个对象就相等，父类equals方法比较的就是batch是否相同）。因此BigCar的equals方法应该做如下修改：

@Override

public boolean equals(Object obj) {

if (obj instanceof BigCar) {

BigCar bc = (BigCar) obj;

return superequals(bc) && count == bccount;

}

return superequals(obj);

}

这样运行的结果就都为true了。但是到这里问题并没有结束，虽然符合了对称性，却还没符合传递性，实例如下：

package comzejiantest;

public class BigCar extends Car {

int count;

public BigCar(int batch, int count) {

super(batch);

thiscount = count;

}

@Override

public boolean equals(Object obj) {

if (obj instanceof BigCar) {

BigCar bc = (BigCar) obj;

return superequals(bc) && count == bccount;

}

return superequals(obj);

}

public static void main(String[] args) {

Car c = new Car(1);

BigCar bc = new BigCar(1, 20);

BigCar bc2 = new BigCar(1, 22);

Systemoutprintln(bcequals(c));

Systemoutprintln(cequals(bc2));

Systemoutprintln(bcequals(bc2));

}

}

运行结果：

true

true

false

bc，bc2，c的批次都是相同的，按我们之前的需求应该是相等，而且也应该符合equals的传递性才对。但是事实上运行结果却不是这样，违背了传递性。出现这种情况根本原因在于：

父类与子类进行混合比较。

子类中声明了新变量，并且在子类equals方法使用了新增的成员变量作为判断对象是否相等的条件。

只要满足上面两个条件，equals方法的传递性便失效了。而且目前并没有直接的方法可以解决这个问题。因此我们在重写equals方法时这一点需要特别注意。虽然没有直接的解决方法，但是间接的解决方案还说有滴，那就是通过组合的方式来代替继承,还有一点要注意的是组合的方式并非真正意义上的解决问题（只是让它们间的比较都返回了false，从而不违背传递性，然而并没有实现我们上面batch相同对象就相等的需求），而是让equals方法满足各种特性的前提下，让代码看起来更加合情合理，代码如下：

package comzejiantest;

public class Combination4BigCar {

private Car c;

private int count;

public Combination4BigCar(int batch, int count) {

c = new Car(batch);

thiscount = count;

}

@Override

public boolean equals(Object obj) {

if (obj instanceof Combination4BigCar) {

Combination4BigCar bc = (Combination4BigCar) obj;

return cequals(bcc) && count == bccount;

}

return false;

}

}

从代码来看即使batch相同，Combination4BigCar类的对象与Car类的对象间的比较也永远都是false，但是这样看起来也就合情合理了，毕竟Combination4BigCar也不是Car的子类，因此equals方法也就没必要提供任何对Car的比较支持，同时也不会违背了equals方法的传递性。

4equals()的重写规则之必要性深入解读

前面我们一再强调了equals方法重写必须遵守的规则，接下来我们就是分析一个反面的例子，看看不遵守这些规则到底会造成什么样的后果。

package comzejiantest;

import javautilArrayList;

import javautilList;

/ 反面例子 @author zejian /

public class AbnormalResult {

public static void main(String[] args) {

List<A> list = new ArrayList<A>();

A a = new A();

B b = new B();

listadd(a);

Systemoutprintln("listcontains(a)->" + listcontains(a));

Systemoutprintln("listcontains(b)->" + listcontains(b));

listclear();

listadd(b);

Systemoutprintln("listcontains(a)->" + listcontains(a));

Systemoutprintln("listcontains(b)->" + listcontains(b));

}

static class A {

@Override

public boolean equals(Object obj) {

return obj instanceof A;

}

}

static class B extends A {

@Override

public boolean equals(Object obj) {

return obj instanceof B;

}

}

}

上面的代码，我们声明了 A,B两个类，注意必须是static，否则无法被main调用。B类继承A，两个类都重写了equals方法，但是根据我们前面的分析，这样重写是没有遵守对称性原则的，我们先来看看运行结果：

listcontains(a)->true

listcontains(b)->false

listcontains(a)->true

listcontains(b)->true

19行和24行的输出没什么好说的，将a，b分别加入list中，list中自然会含有a，b。但是为什么20行和23行结果会不一样呢？我们先来看看contains方法内部实现

@Override

public boolean contains(Object o) {

return indexOf(o) != -1;

}

进入indexof方法

@Override

public int indexOf(Object o) {

E[] a = thisa;

if (o == null) {

for (int i = 0; i < alength; i++)

if (a[i] == null)

return i;

} else {

for (int i = 0; i < alength; i++)

if (oequals(a[i]))

return i;

}

return -1;

}

可以看出最终调用的是对象的equals方法，所以当调用20行代码listcontains(b)时，实际上调用了

bequals(a[i]),a[i]是集合中的元素集合中的类型而且为A类型(只添加了a对象)，虽然B继承了A,但此时

a[i] instanceof B

结果为false，equals方法也就会返回false；而当调用23行代码listcontains(a)时，实际上调用了aequal(a[i]),其中a[i]是集合中的元素而且为B类型(只添加了b对象)，由于B类型肯定是A类型（B继承了A），所以

a[i] instanceof A

结果为true，equals方法也就会返回true，这就是整个过程。但很明显结果是有问题的，因为我们的 list的泛型是A,而B又继承了A，此时无论加入了a还是b，都属于同种类型，所以无论是contains(a),还是contains(b)都应该返回true才算正常。而最终却出现上面的结果，这就是因为重写equals方法时没遵守对称性原则导致的结果，如果没遵守传递性也同样会造成上述的结果。当然这里的解决方法也比较简单，我们只要将B类的equals方法修改一下就可以了。

static class B extends A{

@Override

public boolean equals(Object obj) {

if(obj instanceof B){

return true;

}

return superequals(obj);

}

}

到此，我们也应该明白了重写equals必须遵守几点原则的重要性了。当然这里不止是list，只要是java集合类或者java类库中的其他方法，重写equals不遵守5点原则的话，都可能出现意想不到的结果。

5为什么重写equals()的同时还得重写hashCode()

这个问题之前我也很好奇，不过最后还是在书上得到了比较明朗的解释，当然这个问题主要是针对映射相关的 *** 作（Map接口）。学过数据结构的同学都知道Map接口的类会使用到键对象的哈希码，当我们调用put方法或者get方法对Map容器进行 *** 作时，都是根据键对象的哈希码来计算存储位置的，因此如果我们对哈希码的获取没有相关保证，就可能会得不到预期的结果。在java中，我们可以使用hashCode()来获取对象的哈希码，其值就是对象的存储地址，这个方法在Object类中声明，因此所有的子类都含有该方法。那我们先来认识一下hashCode()这个方法吧。hashCode的意思就是散列码，也就是哈希码，是由对象导出的一个整型值，散列码是没有规律的，如果x与y是两个不同的对象，那么xhashCode()与yhashCode()基本是不会相同的，下面通过String类的hashCode()计算一组散列码：

package comzejiantest;

public class HashCodeTest {

public static void main(String[] args) {

int hash=0;

String s="ok";

StringBuilder sb =new StringBuilder(s);

Systemoutprintln(shashCode()+" "+sbhashCode());

String t = new String("ok");

StringBuilder tb =new StringBuilder(s);

Systemoutprintln(thashCode()+" "+tbhashCode());

}

}

运行结果：

3548 1829164700

3548 2018699554

我们可以看出，字符串s与t拥有相同的散列码，这是因为字符串的散列码是由内容导出的。而字符串缓冲sb与tb却有着不同的散列码，这是因为StringBuilder没有重写hashCode方法，它的散列码是由Object类默认的hashCode方法计算出来的对象存储地址，所以散列码自然也就不同了。那么我们该如何重写出一个较好的hashCode方法呢，其实并不难，我们只要合理地组织对象的散列码，就能够让不同的对象产生比较均匀的散列码。

原文链接：>

下面我们来说一下eureka的增量获取。

ApplicationsappsHashCode ，应用集合一致性哈希码。

增量获取注册的应用集合( Applications ) 时，Eureka-Client 会获取到：

Eureka-Server 近期变化( 注册、下线 )的应用集合

Eureka-Server 应用集合一致性哈希码

Eureka-Client 将变化的应用集合和本地缓存的应用集合进行合并后进行计算本地的应用集合一致性哈希码。若两个哈希码相等，意味着增量获取成功；若不相等，意味着增量获取失败，Eureka-Client 重新和 Eureka-Server 全量获取应用集合。

计算公式

appsHashCode = status+count

使用每个应用实例状态( status ) + 数量( count )拼接出一致性哈希码。若数量为 0 ，该应用实例状态不进行拼接。状态以字符串大小排序。

举个例子，8 个 UP ，0 个 DOWN ，则 appsHashCode = UP_8_ 。8 个 UP ，2 个 DOWN ，则 appsHashCode = DOWN_2_UP_8_ 。

看下Applications的getReconcileHashCode方法

调用 populateInstanceCountMap方法，计算每个应用实例状态的数量，看下具体的实现

调用 getReconcileHashCode方法，计算 hashcode，看下具体的实现

调用 DiscoveryClient的getAndUpdateDelta方法，增量获取注册信息，并刷新本地缓存，看下具体的实现

调用 updateDelta方法，将变化的应用集合和本地缓存的应用集合进行合并，看下具体的实现

ApplicationsResource，处理所有应用的请求 *** 作的 Resource ( Controller )。

接收增量获取请求，映射 ApplicationsResource#getContainers() 方法。

AbstractInstanceRegistryrecentlyChangedQueue，最近租约变更记录队列。看下具体的实现

当应用实例注册、下线、状态变更时，创建最近租约变更记录( RecentlyChangedItem ) 到队列。

后台任务定时顺序扫描队列，当 lastUpdateTime 超过一定时长后进行移除。

配置 eurekadeltaRetentionTimerIntervalInMs， 移除队列里过期的租约变更记录的定时任务执行频率，单位：毫秒。默认值 ：30 1000 毫秒。

配置 eurekaretentionTimeInMSInDeltaQueue，租约变更记录过期时长，单位：毫秒。默认值 ： 3 60 1000 毫秒。

在 generatePayload方法里，调用 AbstractInstanceRegistry的getApplicationDeltas方法，获取近期变化的应用集合，看下具体的实现

eureka的增量获取过程就完成了。

任何类均为Object类的间接子类，所以均继承方法public int hashCode()

该方法返回的值一般是通过将该对象的内部地址转换成一个整数来实现的。

这样能保证每个对象的哈希码值不一样。

与特征码的用法一样。在hash前加上“magnet:xt=urn:btih:”，再复制进迅雷里面，就能得到种子。torrent文件本质上是文本文件，包含Tracker信息和文件信息两部分。

Tracker信息主要是BT下载中需要用到的Tracker服务器的地址和针对Tracker服务器的设置，文件信息是根据对目标文件的计算生成的，计算结果根据BitTorrent协议内的B编码规则进行编码。

它的主要原理是需要把提供下载的文件虚拟分成大小相等的块，块大小必须为2k的整数次方（由于是虚拟分块，硬盘上并不产生各个块文件），并把每个块的索引信息和Hash验证码写入torrent文件中；所以，torrent文件就是被下载文件的“索引”。

根据BitTorrent协议，文件发布者会根据要发布的文件生成提供一个种子文件。下载者要下载文件内容，需要先得到相应的种子文件，然后使用BT客户端软件进行下载。

HashCode（）的作用是为每一个引用类型的元素分配一个唯一的哈希码，北京电脑培训发现这个哈希码就像对象的引用地址一样，在内存中不会重复，是一个唯一值。

在Map元素存储时，将哈希码通过计算，生成一个在数组长度范围内的数，这里我用 index代替解释，然后将index设定为Map元素在数组中的下标，将Map元素存储在所对应的index位置上，这样在进行查找Map元素时就可以通过该Map元素的哈希码对数组长度取余数即可直接在数组中找到对应的Map元素。

这里我先对获得index的计算方式进行介绍，我们知道，数组有固定的长度，那么只要我们将哈希码对数组长度取余数，那么这个余数一定是在数组长度范围内的，也就是在0-数组长度减一的范围内，这样正好是数组下表的范围。

即：哈希码%数组长度 =  [0, 数组长度-1]

当然，这里有一点需要注意，不同的哈希码对数组长度取余数之后，可能得到相同的余数，在这里，链表就派上了用场。

采用这样的存储结构，在查找Map元素时，只需要通过分配给每一个元素的哈希码%数组长度，即可得到该Map元素在数组中的索引值，然后通过索引值找到Map元素在数组中的位置，如果改位置链表存在多个元素，只需对该位置的链表进行便利查找即可找到对应的Map元素值，极大地提高了查找效率。上海尚学堂java培训信恒涛原创，转载请说明出处。

谁说的有这个东西的**都看不了啊 哈希码相当于文件的“身份z”，每个不同的文件有不同的哈希码。。哈希码一般有16位，又称MD5码。 有的网站提供下载文件的哈希码，是为了让下载者可以验证下载文件的正确性，防止黑客等人往里面加东西啊的

不知道你问的是编程语言中的HashCode吧？（当然编程语言中的HashCode就是运用了哈希码来实现快速查找的）。

哈希码是根据有限输入以最大限度产生随即分布的输出，说白了就是像一个函数：y=f(x)，它的目的就是对理论上的所有输入的x产生对应的y值，目的也就是1、保证每个x都最好有且只有一个y与之对应（当然这个不是非常难实现）。 2、对于输入的x，产生的y应该在整数范围内足够随即——这样，产生y很高效！

如果知道由x生成y的函数，那么根据y就可以知道x了，哈希码终归算个函数。

你把问题再具体些，希望能帮助你。如果是编程语言中的HashCode，我下来再补充！

以上就是关于iOS中的哈希表全部的内容，包括:iOS中的哈希表、请问各位大佬这道java的重写equals和重写hashcode方法内部是什么意思呀、Eurake源码分析（十一） 增量获取等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！