求大神解答下面每行的代码注释，js文件的，初学者，看不懂，一个是请求URL参数的，一个是格式化函数。

function getUrlVars()

{

var vars = [], hash

var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&')//获取一个url的参数（?后面的 用&分割） 变成数组

for(var i = 0i <hashes.lengthi++)//数组循环

{

hash = hashes[i].split('=')//一个参数 例如a=4

vars.push(hash[0])//hash数组添加a

vars[hash[0]] = hash[1]//赋值vars[a] 值为4

}

return vars//返回hash数组

}

function format_number(pnumber,decimals){

if (isNaN(pnumber)) { return 0}//pnumber 空 返回0

if (pnumber=='') { return 0}//pnumber 空 返回0

var snum = new String(pnumber)//转换为string

var sec = snum.split('.')//.分割为数组

var whole = parseFloat(sec[0])//转换为float

var result = ''

if(sec.length >1){

var dec = new String(sec[1])

dec = String(parseFloat(sec[1])/Math.pow(10,(dec.length - decimals)))//转换

dec = String(whole + Math.round(parseFloat(dec))/Math.pow(10,decimals))//转换

var dot = dec.indexOf('.')//获取第一个.的位置

if(dot == -1){//如果没有点

dec += '.'//后边加个点

dot = dec.indexOf('.')//再获取第一个点的位置

}

while(dec.length <= dot + decimals) { dec += '0'}//dec长度小于等于后面的 就加0 直到长度比后边大

result = dec//赋值

} else{

var dot

var dec = new String(whole)//转换string

dec += '.'//后边加点

dot = dec.indexOf('.') //获取第一个点位置

while(dec.length <= dot + decimals) { dec += '0'}//dec长度小于等于后面的 就加0 直到长度比后边大result = dec

}

return result//返回值

}

先看一下hash表的结构图：

哈希表（Hash table，也叫散列表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表

白话一点的说就是通过把Key通过一个固定的算法函数（hash函数）转换成一个整型数字，然后就对该数字对数组的长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。

先了解一下下面几个常说的几个关键字是什么：

key ：我们输入待查找的值

value ：我们想要获取的内容

hash值 ：key通过hash函数算出的值（对数组长度取模，便可得到数组下标）

hash函数（散列函数） ：存在一种函数F，根据这个函数和查找关键字key，可以直接确定查找值所在位置，而不需要一个个遍历比较。这样就预先知道key在的位置，直接找到数据，提升效率。

即

地址index=F(key)

hash函数就是根据key计算出该存储地址的位置，hash表就是基于hash函数建立的一种查找表。

方法有很多种，比如直接定址法、数字分析法、平方取中法、折叠法、随机数法、除留余数法等，网上相关介绍有很多，这里就不重点说这个了

对不同的关键字可能得到同一散列地址， 即k1≠k2，而f(k1)=f(k2)，或f(k1) MOD 容量 =f(k2) MOD 容量 ，这种现象称为 碰撞 ，亦称 冲突 。

通过构造性能良好的hash函数，可以减少冲突，但一般不可能完全避免冲突，因此解决冲突是hash表的另一个关键问题。

创建和查找hash表都会遇到冲突，两种情况下解决冲突的方法应该一致。

这里要提到两个参数： 初始容量 ， 加载因子 ，这两个参数是影响hash表性能的重要参数。

容量 ： 表示hash表中数组的长度，初始容量是创建hash表时的容量。

加载因子 ： 是hash表在其容量自动增加之前可以达到多满的一种尺度（存储元素的个数），它衡量的是一个散列表的空间的使用程度。

loadFactor = 加载因子 / 容量

一般情况下，当loadFactor <= 1时，hash表查找的期望复杂度为O(1).

对使用链表法的散列表来说， 负载因子越大，对空间的利用更充分，然后后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费 。系统默认负载因子为0.75。

当hash表中元素越来越多的时候，碰撞的几率也就越来越高（因为数组的长度是固定的），所以为了提高查询的效率，就要对数组进行扩容。而在数组扩容之后，最消耗性能的点就出现了，原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是 扩容 。

什么时候进行扩容呢？当表中 元素个数超过了容量 * loadFactor 时，就会进行数组扩容。

Foundation框架下提供了很多高级数据结构，很多都是和Core Foundation下的相对应，例如NSSet就是和_CFSet相对应，NSDictionary就是和_CFDictionary相对应。 源码

这里说的hash并不是之前说的hash表，而是一个方法。为什么要有hash方法？

这个问题需要从hash表数据结构说起，首先看下如何在数组中查找某个成员

在数组未排序的情况下，查找的时间复杂度是O(n)（n为数组长度）。hash表的出现，提高了查找速度，当成员被加入到hash表中时，会计算出一个hash值，hash值对数组长度取模，会得到该成员在数组中的位置。

通过这个位置可以将查找的时间复杂度优化到O(1)，前提是在不发生冲突的情况下。

这里的hash值是通过hash方法计算出来的，且hash方法返回的hash值最好唯一

和数组相比，基于hash值索引的hash表查找某个成员的过程：

可以看出优势比较明显，最坏的情况和数组也相差无几。

重写person的hash方法和copyWithZone方法，方便查看hash方法是否被调用：

打印结果：

可以了解到： hash方法只在对象被添加到NSSet和设置为NSDictionary的key时被调用

NSSet添加新成员时，需要根据hash值来快速查找成员，以保证集合中是否已经存在该成员。

NSDictionary在查找key时，也是利用了key的hash值来提高查找的效率。

这里可以得到这个结论：

相等变量的hash结果总是相同的，不相等变量的hash结果有可能相同

根据数据结构可以发现set内部使用了指针数组来保存keys，可以从 源码 中了解到采用的是连续存储的方式存储。

NSSet添加key，key值会根据特定的hash函数算出hash值，然后存储数据的时候，会根据hash函数算出来的值，找到对应的下标，如果该下标下已有数据，开放定址法后移动插入，如果数组到达阈值，这个时候就会进行扩容，然后重新hash插入。查询速度就可以和连续性存储的数据一样接近O(1)了。

和上面的集合NSSet相比较，多了一个指针数组values。

通过比较集合NSSet和字典NSDictionary的 源码 可以知道两者实现的原理差不多，而字典则用了两个数组keys和values，说明这两个数据是被分开存储的。

通过源码可以看到，当有重复的key插入到字典NSDictionary时，会覆盖旧值，而集合NSSet则什么都不做，保证了里面的元素不会重复。

大家都知道，字典里的键值对key-value是一一对应的关系，从数据结构可以看出，key和value是分别存储在两个不同的数组里，这里面是如何对key、value进行绑定的呢？

首先 key利用hash函数算出hash值，然后对数组的长度取模，得到数组下标的位置，同样将这个地址对应到values数组的下标，就匹配到相应的value。 注意到上面的这句话，要保证一点， 就是keys和values这两个数组的长度要一致 。所以扩容的时候，需要对keys和values两个数组一起扩容。

对于字典NSDictionary设置的key和value，key值会根据特定的hash函数算出hash值，keys和values同样多，利用hash值对数组长度取模，得到其对应的下标index，如果下标已有数据，开放定址法后移插入，如果数组达到阈值，就扩容，然后重新hash插入。这样的机制就把一些不连续的key-value值插入到能建立起关系的hash表中。

查找的时候，key根据hash函数以及数组长度，得到下标，然后根据下标直接访问hash表的keys和values，这样查询速度就可以和连续线性存储的数据一样接近O(1)了。

参考文章： 笔记-数据结构之 Hash（OC的粗略实现）

可以直接运行的。。。

public static void main(String[] args) {

HashMap<String, Integer>hm=new HashMap<String, Integer>()

hm.put("Jack1",new Integer(1000))

hm.put("Jack2",new Integer(2000))

hm.put("Jack3",new Integer(3000))

hm.put("Jack4",new Integer(4000))

Integer list[] =new Integer[hm.size()]

//数组的长度是和集合的长度一样的。。动态。

int i = 0

for(Integer str : hm.values()){

list[i]=str

i+=1

}

for(int j=0j<list.lengthj++){

System.out.println(list[j])

}

}

---