引用一下网上的介绍：

Lambda函数（通常所谓的匿名函数）简单来说就是一次性函数，可以在任何时候定义，且经常赋值给一个变量。函数自身和对应变量处于同一个作用域内，当离开变量的作用域后，该函数也将消亡，Lambda不保存任何状态。

闭包(Closure)是指一个可以在自己环境中执行的函数，调用时可以访问已经绑定的变量。它们来源于函数式编程世界，在那里有非常多的应用。闭包和Lambda函数类似，但是闭包还可以和定义时指定的外部变量交互。

我们可以简单地理解为Closure可以访问父级视野（parent scope）定义的变量，而Lambda不行。
下面举个例子来说明，比如我想对某一数组的每个元素追加一个字符后缀，后缀的内容作为参数传递给函数。

//Lambda实现代码：
function appendPostfix($array, $postfix) {
	$anonyFun = function($e, $p) {
		return $e.'_'.$p;
	};
	return array_map($anonyFun, $array, array_fill(0, count($array), $postfix));
}

由于Lambda不能直接调用$postfix变量，所以只好对匿名函数多加个参数，并在调用array_map时将$postfix作为callback参数再次传递一次。

//Closure实现代码：
function appendPostfix($array, $postfix) {
	$anonyFun = function($e) use($postfix) {
		return $e.'_'.$postfix;
	};
	return array_map($anonyFun, $array);
}

通过使用use关键字，将$postfix传入匿名函数（值传递），于是代码简洁了许多。这里只是说明一下闭包的应用，当然可以通过其他方式实现此功能。

那么对于PHP语言来讲使用闭包都有哪些好处：
1. 代码简洁
不用将函数定义在其他地方，提高代码可读性。也不用为避免函数名重复而而额外添加诸如“if(!function_exists(‘xxx’))” 的判断。如果你留意Ruby或Python的代码，会惊讶地发现其简洁的风格和直观的可读性。虽然目前PHP的闭包还达不到那些动态语言的水平，但毕竟是向那个方向所作出的第一步尝试。

2.性能
如果按照以前的办法动态定义一个函数(利用create_function)，会有几点不足：由于都是字符串形式，一般IDE无法实现语法高亮；还有就是动态函数是在运行期编译的，而非编译期，所以不能通过opcode来缓存优化性能。

相对的，PHP的闭包有哪些缺点或者说不足：
1. 留意内存泄露
先看一段简单的代码：

function increase() {
	$x = 10;
	return function() use (&$x) {
		return $x++;
	};
}
 
$f = increase();
 
$r = $f();
var_dump($r);
$r = $f();
var_dump($r);

increase方法中的$x是函数局部变量，但是在执行完$f = increase()后并没有被释放掉，因为返回的闭包一直保留着对其的引用。所以在程序输出结果中$x的值会不断递增。这说成是需要注意的地方，不如视为一种编程技巧，我们可以利用这种特性延长函数内部变量的生命周期，相当于在闭包中定义了一个全局的静态变量。

2. 局限
直到5.3.2，PHP的闭包中还不能直接使用$this，需要先将$this赋给一个临时变量，再通过这个临时变量操纵$this，比如：

class Foo
{
    private $x = 3;
    private function f()
    {
        return 15;
    } 
 
    public function getClosureUsingPrivates()
    {
        $self = $this; //注意这行
        return function () use ($self) {
            return $self->x * $self->f();
        };
    }
}

当然，闭包还有很多特性和应用可以挖掘，借鉴下网上总结的常用闭包应用：重构、定制、遍历集合、管理资源、实施策略。
以后可以考虑多使用闭包的形式，以此来学习和体验闭包带来的不同体验。

部分参考文章：
Lambda functions and closures
谈PHP 闭包特性在实际应用中的问题

最开始是在淘宝UED官方博客上看到的.觉得很不错,以为是flash. F12一下才知道是js实现的.当时没具体看,现在开始学javascript了,突然想到这个效果,决定挑战一下哈~开始吧~

Mockup

第一步:HTML&CSS

先不要着急写代码,先要考虑考虑实现这个效果对于代码结构上有什么特别的要求,我想到了两个方案:

1.一个小图容器,一个放大镜容器.原图做为放大镜容器的背景

2.一个小图容器,一个放大镜容器.原图做为放大镜子容器

这两个方案其实实现起来差别不大,但是考虑到将来图片有可能是动态读取出来的,而且大小不定,所以我们不推荐放在CSS背景中来实现,最后选择第二种方案.

HTML代码片段如下:

<div onMouseMove="imgZoomOut(event)" id="smallImgCon">
	<img src="img/airport_small_1.jpg" id="smallImg"/>
	<div id="magnifierCon" style="display:none">
		<img src="img/magnifier.png" id="magnifierBg"/>
		<img src="img/airport_large_1.jpg" id="largeImg"/>
	</div>
</div>

CSS代码片段如下:

#smallImgCon {position:relative;left:0;top:0;}
#magnifierCon {height:276px;width:276px;position:absolute;overflow:hidden;z-index:3}
	#magnifierCon img#magnifierBg {position:absolute;z-index:2}
	#magnifierCon img#largeImg {position:absolute;z-index:1}

第二步:准备好我们需要的信息

我们暂且不去考虑图片大小不定这样一种情况,我们目前可以只针对这其中一张图片.只是放大镜大小固定而已.这里我使用的大小是276*276.
大致思路是可以通过下图来了解:

Step1.得到小图所在位置,即坐标,并将其做为原点.
Step2.得到鼠标当前所在位置,这里是指相对于原点的,所以需要减去上一步得到的坐标值.
Step3.有了这个距离,再减去放大镜长宽的一半就得到了放大镜的坐标.即它相对于原点的距离.
Step4.关键一步大图如何定位呢?
这里需要注意的是这几个容器的层级关系:最外层容器是爷爷,放大镜与小图同是兄弟俩,大图是孙子(哈哈~~不是骂人哈)
说白了就是将光标与原点之间的距离*缩放比例=相对应的大图坐标
再减去放大镜宽高一半就得到了超出放大镜的那段距离 也就是大图相对于其父级容器(放大镜)的距离.将这两个值的赋给大图的left,top就基本搞定了~~
大家晕不?呵呵 我都有点儿晕了…思路及表达能力有待进一步提高

那么按照以上步骤写代码吧:
主要代码如下

	var smallImgCon = document.getElementById("smallImgCon");
	var smallImg = document.getElementById("smallImg");
	var magnifierCon = document.getElementById("magnifierCon");
	var magnifierBg = document.getElementById("magnifierBg");
	var largeImg = document.getElementById("largeImg");

	function imgZoomOut(event) {

		//Step 1得到小图位置,即原点.
		smallImgConLocationX = smallImgCon.offsetLeft;
		smallImgConLocationY = smallImgCon.offsetTop;

		//Step2.得到光标相对于原点的坐标值.
		x = event.clientX - smallImgConLocationX;
		y = event.clientY - smallImgConLocationY;

		//Step3.放大镜相对于原点的距离.
		magnifierCon.style.left = x - magnifierWidth/2 + "px";
		magnifierCon.style.top = y - magnifierHeight/2 + "px";

		//Step4.大图定位
		x = - x*(largeImgWidth/smallImgWidth) + magnifierWidth/2;
		y = - y*(largeImgWidth/smallImgWidth) + magnifierHeight/2;

		largeImg.style.left = x + "px";
		largeImg.style.top = y + "px";

	}

写到这里基本结构有了,但还有一些问题需要考虑:

1. 鼠标移到图像外面了怎么办?
2. 如何动态得到各个元素的大小,便于将来扩展呢?

于是我们要添加另外两个函数跟一个条件判断:

	function getImageSize(imageEl) {
		var i = new Image();
		i.src = imageEl.src;
		return new Array(i.width, i.height);
	}
	function dispear() {
		magnifierCon.style.display = "none";
	}
	if ( x < 0 || x > smallImgWidth || y < 0 || y > smallImgHeight) {
		dispear();
	}else {
		...
	}

最终效果演示
小提示:大小图最后比例差别大些 这样效果更好更明显~
再次强调,因为是初学,所以代码还有很多地方需要优化,再小的功能也要不断完善,倔倔会在学习中不断完善之前的练习~希望大家能多多帮助倔倔~~:)

知识点总结:

1. 函数之间的调用
2. 数组的定义
3. 鼠标事件的概念

下期预告:图片浏览+放大镜

<?php
/*
数字转汉字
如：123 转为 一百二十三
*/
function num2str($num) {
	if(!is_numeric($num)) return false;

	$ret = '';
	if($num < 0) {
		$ret = '负';
		$num = -$num;
	}

	$zhNumArray = array(
		"1" => "一",
		"2" => "二",
		"3" => "三",
		"4" => "四",
		"5" => "五",
		"6" => "六",
		"7" => "七",
		"8" => "八",
		"9" => "九",
		"0" => "零",
	);

	$bitStrArray = array(
		"1" => "",
		"10" => "十",
		"100" => "百",
		"1000" => "千",
		"10000" => "万",
		"100000000" => "亿",
	);

	$prebit = 0;//上次记录的位数
	krsort($bitStrArray);
	foreach($bitStrArray as $bit => $name) {
		$bit = floatval($bit);
		if($num >= $bit) {
			$tmpNum = floor($num / $bit);
			if($tmpNum >= 10) {
				$tmpRet = num2str($tmpNum);
				$ret .= $tmpRet . $name;
			} else {
				if($prebit/$bit > 10) {//按照中文习惯补零
					$ret .= '0';
				}
				$ret .= $tmpNum . $name;
			}
			$prebit = $bit;
			$num = fmod($num, $bit);//取模
		}
	}

	$ret = str_replace(array_keys($zhNumArray), array_values($zhNumArray), $ret);
	return $ret;
}

$test = '1234567890';
echo num2str($test);
?>

这段代码算不上优美，可读性还凑合，bug肯定会有（那还展示出来干嘛呀- -!）。但我还是幻想万一对人能有所帮助呢，或者引来某个迷路的高手指点一二，都算是件好事。

好，闲话不多说，直接上代码：

<?php
/*
*功能：对于输入的内容按照二分法规则进行分词，遵循以下规则
*实例：imdonkey的主人要发奋了
*结果：imdonkey 的主 主人 人要 要发 发奋 奋了
*/

function binary_split($str) {
	$ret = array();
	$preword = '';
	$preischinese = false;
	for($i = 0; $i < strlen($str); $i++) {
		$cur = $str[$i];
		if(ord($cur) > 0x80) {
			// current is chinese
			if(!empty($preword)) {
				if($preischinese){
					// preword is chinese
					if(strlen($preword) == 4) {
						$ret[] = $preword.$cur;
						$preword = substr($preword, 2);
					}

				} else {
					// preword is non-chinese
					$ret[] = $preword;
					$preword = '';
				}
			}
			$preword .= $cur;
			$preischinese = true;

		} else {
			// current is non-chinese
			if(!empty($preword)) {
				if($preischinese){
					// preword is chinese
					$ret[] = $preword;
					$preword = '';

				} else {
					// preword is non-chinese

				}
			}
			$preword .= $cur;
			$preischinese = false;
		}

	}//end for
	if(!empty($preword)) $ret[] = $preword;

	return $ret;
}

$test = 'imdonkey的主人要发奋了';
print_r(binary_split($test));
?>

这段代码算不上优美，可读性还凑合，bug肯定会有（那还展示出来干嘛呀- -!）。但我还是幻想万一对人能有所帮助呢，或者引来某个迷路的高手指点一二，都算是件好事。

在windows下要运行安装根目录下的vimtutor.bat.打开的文件默认就是一个副本,所以你可以尽情地在上面练习修改.

倔倔现在就要开始练习啦~哈

…

过了一遍vimtutor确实感觉不错~,好多命令都非常吸引人,我已经感觉到了熟练使用了这些命令后,编写代码时会有多么惊人的效率了~~

教程中每讲小结如下:

熟悉Linux的同学应该对Vim很了解,也清楚它的神通广大~可我一做前端爱设计的人对这东西根本没接触.所以接下来的介绍依然是为那些同类的朋友们准备的.很简单,我也尽量将步骤说得详细些~

先记住它是一个编辑器其它的先不用管,马上开始!

安装

了解之前咱得先看看这东西长什么样儿. Download Vim for Win

不用修改什么,一直Next下去就成~除非你要改安装路径跟选择语言.

中文手册安装

这种编辑器的命令忒多,看英文的手册头疼,下个中文的吧.这里

下载之后运行,安装成功后重启Vim,启动界面是中文了,可是菜单上的中文却成了乱码.google之后发现一篇文章,修改后问题解决

配色方案设置及保存

但这次修改明白了Vim的用户设置基本都可以通过在_vimrc这个文件里修改添加

于是修改了配色方案,如果不在_vimrc文件里设置的话,下次打开Vim又会还原到最初始状态.

找到 Vim 官方百科 按照这篇文章 顺便将字体跟大小也一起改了

我目前选用的是Consolas:h14

效果如下:

在Vim下安装zen coding

这里包含了所有安装zen-coding的信息.

如果想了解什么是zen-coding可以参看这里

最后阅读中文手册,练习了一些最基本的操作命令(多了也记不住哈哈).目前感觉很不错~

以后会慢慢熟悉Vim,希望自己能快快进步~大家共勉~:)

最近各种刺激扑面而来,叫我怎能不好好学习?在坨坨同学的指导下 我开始了”又”一次的Javascript之旅~(之所以说”又”是因为07年自己买下了《Javascript高级程序设计》,现在想来真不知道当时自己怎么了….好在是本好书~银子没白花)

先做几个很简单的实例,把自己学习的兴趣提起来.这点很重要.

声明:本人可以说是0基础,所以初学JS的朋友也可以一起学习.高手们可以飘过,多多指导哈

实例一:图片浏览

实现效果:点击”Previous”和”Next” button实现连续几张图片的切换. 很简单吧~

第一步:HTML&CSS

这一步对各位来说应该并不难,不过既然元素少,又是做Demo用的,我们就对自己的要求放松些吧,我说的放松是对于浏览器兼容问题的放松.我们选择HTML5与CSS3.可以暂时不用过多管IE678.(但你可以下载IE9的preview版来看看,也无妨)

主要HTML代码如下:

	<input type="button" id="btn_previous" value="Previous"/>
	<input type="button"  id="btn_next" value="Next"/>
	<ul id="container">
		<li id="pic_1" class="current">
			<img src="../images/demo/pic_1.gif" title="NO.1" alt="NO.1"/>
			<p title="NO.1">NO.1</p>
		</li>
		<li id="pic_2">
			<img src="../images/demo/pic_2.gif" title="NO.2" alt="NO.2"/>
			<p title="NO.2">NO.2</p>
		</li>
		<li id="pic_3">
			<img src="../images/demo/pic_3.gif" title="NO.3" alt="NO.3"/>
			<p title="NO.3">NO.3</p>
		</li>
		<li id="pic_4">
			<img src="../images/demo/pic_4.gif" title="NO.4" alt="NO.4"/>
			<p title="NO.4">NO.4</p>
		</li>
		<li id="pic_5">
			<img src="../images/demo/pic_5.gif" title="NO.5" alt="NO.5"/>
			<p title="NO.5">NO.5</p>
		</li>
	</ul>

第二步:梳理思路

想想需要解决哪几个问题:

1. 怎么知道是显示当前图片的上一张还是下一张?
2. 如何替换当前图片?

好,先解决掉这两个问题事情就好办多了.

1. 我们需要将”向前”和”向后”分别用两个数值来代替,做为参数传给接下来我们要完成的函数,这里用(-1)和(1)来表示.
2. 知道了是向前还是向后之后 我们就要把当前图片隐藏起来,然后显示出它的上一张或者下一张图片.

Ok,那我们就开始吧~

第三步:编写代码

首先我们给函数起个名字,就叫 imgSlider.(也许并不贴切,但以后会改进功能).把要传给这个函数的值取名为n.所以简单写下来函数应该长这个样子:

function imgSlider(n) {

}

然后我们需要一个变量,这个变量用来存储当前显示的是第几张图片,我们先赋一个初始值给它,像这样.

var currentImg = 1;
function imgSlider(n) {

}

为什么要把这个赋值语句写在函数外面呢?(全局变量)因为函数要对这个值做处理,也就是说将来一旦触发了这个函数,currentImg这个值会改变,所以我们将它写在外面.

接下来我们需要得到网页中的几个对象,取得对象的方法是采用document.getElementById(“idname”):

var currentImg = 1;
function imgSlider(n) {
	var currentImgCon = document.getElementById("pic_"+ currentImg);
	var btn_previous = document.getElementById("btn_previous");
	var btn_next = document.getElementById("btn_next");
}

哈哈,现在就到了最关键的步骤了,到目前为至我们还没有用到传进来的参数呢,想想假设现在传进来的是(1),即用户要显示下一张图片的话,我们要做何处理呢?很简单,就是在当前图片基础上+1 显示下一张呗~

var currentImg = 1;
function imgSlider(n) {
	var currentImgCon = document.getElementById("pic_"+ currentImg);
	var btn_previous = document.getElementById("btn_previous");
	var btn_next = document.getElementById("btn_next");
	currentImg = currentImg + n;
	targetImgCon.setAttribute("class","current");
	targetImgCon.className = "current";
}

currentImg加了1后,我们根据currentImg的最新值通过document.getElementById()这个方法找到了我们要显示的那个图片,并且将得到的对象命名为targetImgCon,然后将current这个class加到这个对象上,那么第二张图片就显示出来了.可不要忘记在这之前要先将之前的图片隐藏起来,所以还要对代码要做以下修改

var currentImg = 1;
function imgSlider(n) {
	var currentImgCon = document.getElementById("pic_"+ currentImg);
	var btn_previous = document.getElementById("btn_previous");
	var btn_next = document.getElementById("btn_next");
	currentImgCon.setAttribute("class","");
	currentImgCon.className = "";
	currentImg = currentImg + n;
	var targetImgCon = document.getElementById("pic_"+ currentImg);
	targetImgCon.setAttribute("class","current");
	targetImgCon.className = "current";
}

到此为至主要功能实现了,但完整程度还差好多~.不信可以将事件加到两个button上,如下:

<input type="button" onclick="imgSlider(-1)" id="btn_previous" value="Previous" disabled="disabled"/>
<input type="button" onclick="imgSlider(1)" id="btn_next" value="Next"/>

那么我们还要做什么呢?目前页面中只有5张图片,我们不希望用户一直点击向前向后,那样currentImg数值会越来越大,而执行过程中又取不到数值大于5的图片,会报错.所以现在我们要对临界值做一个判断处理.我们希望只有在1-5这个范围内再做我们以上的那些事情.

var currentImg = 1;
function imgSlider(n) {
	var currentImgCon = document.getElementById("pic_"+ currentImg);
	var btn_previous = document.getElementById("btn_previous");
	var btn_next = document.getElementById("btn_next");
	currentImgCon.setAttribute("class","");
	currentImgCon.className = "";
	currentImg = currentImg + n;
	if (currentImg > 1 || currentImg < 5 ) {
		var targetImgCon = document.getElementById("pic_"+ currentImg);
		targetImgCon.setAttribute("class","current");
		targetImgCon.className = "current";
	}
}

可运行一下,发现到第5张时候再点”Next”就什么都显示不出来了,再点”Previous”也没反应了,为什么呢?我们用input来跟踪下currentImg的数值变化:
在HTML中添加一个input:

<input type="text" value="" id="logger"/>

JavaScript做如下修改:

document.getElementById("logger").value = currentImg;

刷新下页面,点到最后发现currentImg的值是6,超出了1-5这个范围,自然执行不了我们if条件里的语句了.怎么解决这个问题呢,其实很简单,当页面当前显示的是第一张图片时我们就将”Previous”button 屏蔽掉,同理,当页面当前显示的是第5张,也就是最后一张的时候屏蔽掉”Next”button,事情就解决了.其它情况下两个button正常显示~~哈哈

初始的时候就要先将”Previous” button 置为disabled

<input type="button" onclick="imgSlider(-1)" id="btn_previous" value="Previous" disabled="disabled"/>

JavaScript添加如下代码:

if(currentImg == 1) {
	btn_previous.setAttribute("disabled","disabled");
}else {
	btn_previous.removeAttribute("disabled");
}

if(currentImg == 5) {
	btn_next.setAttribute("disabled","disabled");
}else {
	btn_next.removeAttribute("disabled");
}

大功告成~~最终效果

知识点:

1. CSS3 渐变http://www.qianduan.net/understand-the-css3-gradient.html
2. CSS Selector
3. CSS 缩写http://www.qianduan.net/css-font-shorthand-attribute-handbook.html
4. input disabled属性
5. function定义
6. 全局变量定义/初始化
7. document.getElementById(“idName”)
8. setAttribute(“attributeName”,”attributeValue”)
9. removeAttribute(“attributeName”)
10. if else

下期预告:放大镜~~~

这个题目是听公司同事说起的，当时我的第一反应也是建立一个哈希表，然后循环检查元素是否已经存在于这个表中，没有就添加进去，并检查下一个，如果有就说明此链表是个环。甚至为了优化性能，可以隔几个检查一次，这样还能减少比对次数。后来google了一下，豁然开朗~

简单说来，就是设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步(如果能证明其他数值性能更高，欢迎补充)，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表)，具体到Java代码是这样的：

首先先定义LinkedNode类，为了简化代码，我只给它设置了一个属性：next

public class LinkedNode {
 
	private LinkedNode next = null;
 
	public void setNext(LinkedNode _next) {
		this.next = _next;
	}
 
	public LinkedNode next() {
		return this.next;
	}
}

然后开始写测试代码：

public class CircleChecker {
 
	public static final int HASHCHECK = 1;
	public static final int STEPCHECK = 2;
 
	/**
	 * Generate a linked list
	 * @param circle if true, return a circle list
	 * @param capital list size
	 * @return linked list
	 */
	private List<LinkedNode> getLinkedList(boolean circle, int capital) {
		List<LinkedNode> list = new LinkedList<LinkedNode>();
		LinkedNode head = new LinkedNode();
		list.add(head);
		while (--capital > 0) {
			LinkedNode node = new LinkedNode();
			list.get(list.size() - 1).setNext(node);
			list.add(node);
		}
		if (circle) {
			list.get(list.size() - 1).setNext(head);
		}
		System.out.println("List size is :" + list.size() + "\r\n");
		return list;
	}
 
	public boolean hashCheck(List<LinkedNode> list) {
		boolean hasCircle = false;
		Set<LinkedNode> hash = new HashSet<LinkedNode>();
 
		LinkedNode node = list.get(0);
		hash.add(node);
		int times = 0;
		int step = 2;
		while (node.next() != null) {
			for (int i = 0; i < step && node.next() != null; i++) {
				node = node.next();
			}
			if(!hash.add(node)) {
				hasCircle = true;
				break;
			}
			times++;
		}
		System.out.println("Check Time: " + times);
		return hasCircle;
	}
 
	public boolean stepCheck(List<LinkedNode> list) {
		boolean hasCircle = false;
		int i;
		int step1 = 1;
		int step2 = 2;
 
		LinkedNode node1 = list.get(0);
		LinkedNode node2 = list.get(0);
		int times = 0;
		while (node1.next() != null && node2.next() != null) {
			for (i = 0; i < step1 && node1.next() != null; i++) {
				node1 = node1.next();
			}
			for (i = 0; i < step2 && node2.next() != null; i++) {
				node2 = node2.next();
			}
			if (node1 == node2) {
				hasCircle = true;
				break;
			}
			times++;
		}
		System.out.println("Check Time: " + times);
		return hasCircle;
	}
 
	public void startCheck(List<LinkedNode> list, int mode) {
		long start = System.currentTimeMillis();
		boolean result = false;
		switch (mode) {
		case HASHCHECK:
			System.out.println("[Hash Check]");
			result = this.hashCheck(list);
			break;
		case STEPCHECK:
			System.out.println("[Step Check]");
			result = this.stepCheck(list);
			break;
		default:
			System.err.println("Unsupported Mode");
		}
		long end = System.currentTimeMillis();
		System.out.println("RunningTime: " + (end - start));
		System.out.println("Result is " + result + "\r\n");
	}
 
	public static void main(String[] arg) {
		CircleChecker app = new CircleChecker();
		List<LinkedNode> testList = app.getLinkedList(true, 500000);
		app.startCheck(testList, HASHCHECK);
		app.startCheck(testList, STEPCHECK);
	}
 
}

运行结果如下：
List size is :500000

[Hash Check]
Check Time: 249999
RunningTime: 453
Result is true

[Step Check]
Check Time: 499999
RunningTime: 40
Result is true

这是对一个环路链表的检测结果，下面再试试无环路链表。把main函数中的

List<LinkedNode> testList = app.getLinkedList(true, 500000);

改为：

List<LinkedNode> testList = app.getLinkedList(false, 500000);

运行结果如下：
List size is :500000

[Hash Check]
Check Time: 250000
RunningTime: 448
Result is false

[Step Check]
Check Time: 250000
RunningTime: 24
Result is false

可见虽然哈希表检查法可能在比较次数上较少，但是总耗时多了很多，主要耗费在hash.add(node)上，因为选择的是Set，所以为了保证元素唯一性，在add数据时会检查是否已存在。而且当要检查的元素数量巨大时，要占用非常大的内存，甚至OutOfMemoryError。而快慢两步走法（sorry，我起得名字有点土），仅仅进行指针比较既可，极其快速，而且不占内存！
这才是我们应该追求的终极目标

$array = array(
    "id1" => 2147483647,
    "id2" => 2147483648
);
$json = json_encode($array);
$out = json_decode($json, true);
var_dump($out);

理论上应该看到：

array(2) {
    ["id1"]=>int(2147483647)
    ["id2"]=>int(2147483648)
}

但实际在我的电脑上却得到：

array(2) {
    ["id1"]=>int(2147483647)
    ["id2"]=>int(-2147483646)
}

这是由PHP整数值范围决定的，而这个范围依赖于操作系统。在32位操作系统中，PHP的整数最大值是2147483647，你可以通过输出PHP_INT_MAX看到。

一般情况下，你赋值一个很大的数，PHP会自动判定这个数值的范围并自动转换类型，如：

$large_number = 2147483647;
var_dump($large_number);                     // int(2147483647)
 
$large_number = 2147483648;
var_dump($large_number);                     // float(2147483648)
 
$million = 1000000;
$large_number =  50000 * $million;
var_dump($large_number);                     // float(50000000000)

但是在json_decode方法中没有进行这种检测，这是PHP（旧版本）的bug，在5.3以后的版本，就不存在这个问题了。

如果你不想更新你的PHP，那还有个办法，就是将数字转为字符串。还是以上面的代码为例：

$array = array(
    "id1" => 2147483647,
    "id2" => 2147483648
);
$json = json_encode($array);
 
$json = preg_replace('/("id\d":)(\d{9,})/i', '${1}"${2}"', $json);
 
$out = json_decode($json, true);
var_dump($out);

当然，这个怎么替换是按需而定的，而且需要比较细致的测试。

会议主题：W3C CEO与工程师面对面
会议日期：5月9日(周日)下午1点开始
会议地点：北航会议中心
预定人数：50人
参与费用：不收取任何费用
主办方：W3C中国，Web标准化交流会

W3C CEO Dr. Jeff Jaffe 5月来北京, Web标准化交流会努力争取到了这次难得的机会,邀请到Dr. Jeff Jaffe与工程师一起探讨Web前端的发展和与之相关的各类问题.希望大家积极报名.相信一定会收获不小~