某set, 存一些Email, 如下:
e1@abc.com 
e1@Abc.com
e1@ABc.com
e2@ABC.com
e3@abC.com

很明显, 一共3个不同邮箱,

现在创建了Email类, 需要将这帮Email放入一个HashSet中, 当然,

e1@abc.com
e1@abc.com
e1@Abc.com
e1@ABc.com
这几个是一模一样的, 都是e1@abc.com

因此需要重写Email的equlas 和hashCode两个函数, 以便保证Set的唯一性.

代码:

	//重写equals
	public boolean equals(Object obj) {
		if(this == obj) {
			return true;
		}

		final Email email = (Email)obj;

		if(this.pB.equals(email.pB) && this.pA.equalsIgnoreCase(email.pA)) {
			return true;
		}else {
			return false;
		}
	}

	//重写hashCode
	public int hashCode() {
		int result;
		result = pB.hashCode() + pA.toLowerCase().hashCode();
		return result;
	}

在Email外部将这开始提到的这帮email建立为Email类, 并加入到某Set中,

注意: 为了保证HashSet正常工作, 要求当两个对象用equals()方法比较结果为True时, 起hashCode也必须相同, 因此覆盖了equals之后 必须覆盖hashCode.

结果是该Set的size为3 – 达到要求….

----------Post from: @LiGuoliang.com, 欢迎回来~----------

排序的算法比较多,大概可分为:
* 插入排序
* 冒泡排序
* 选择排序
* 快速排序
* 堆排序
* 归并排序
* 基数排序
* 希尔排序
在这我就找俩最简单的练练手先, 写的不一定对, 欢迎指正, 批评才是我前进的动力…

直接插入排序  Insertion Sort

	 }
	/**
	 * 插入排序[直接插入排序 Insertion Sort]
	 */
	 public static function insertionSort(arrayToBeSorted:Array):void {
	 	for(var i:int = 0; i0; j--) {
		 		if(arrayToBeSorted[j-1]>arrayToBeSorted[i]) {
		 			arrayToBeSorted[j] = arrayToBeSorted[j-1];
		 		}else {
		 			break;
		 		}
		 		trace(j);
		 	}
		 	arrayToBeSorted[j] = temp;
	 	}
	 	trace(arrayToBeSorted);
	 }

交互排序[冒泡排序 Bubble Sort]

 /**
	 * 交互排序[冒泡排序 Bubble Sort]
	 */
	 public static function bubbleSort(arraytoBeSorted:Array):void {
	 	var startIndex:int = 0;
	 	var tempIndex:int;
	 	for(var j:int = arraytoBeSorted.length - 1; j>0; j--) {
		 	for(var i:int = arraytoBeSorted.length - 1; i>startIndex; i--) {
		 		if(arraytoBeSorted[i-1]>arraytoBeSorted[i]) {
		 			//swap(arraytoBeSorted[i], arraytoBeSorted[i-1]);
		 			var temp:int = arraytoBeSorted[i];
		 			arraytoBeSorted[i] = arraytoBeSorted[i-1];
		 			arraytoBeSorted[i-1] = temp;
		 			tempIndex = i;
		 		}
		 	}//end of for
	 		startIndex = tempIndex;
	 		trace("StartIndex: " + startIndex);
	 	trace("冒泡法排序结果: " + arraytoBeSorted);
		 }//end of for
	 }

双向冒泡:

 /**
	 * 交互排序[双向冒泡]
	 */
	 public static function doubleDirectionBubbleSort(arrayToBeSorted:Array):void {
	 	var j:int;
	 	var k:int;
	 	var tempIndex:int = arrayToBeSorted.length;

	 	var startIndex:int = 0;
	 	var endIndex:int = arrayToBeSorted.length - 1;

	 	var change:Boolean = true;
	 	while(startIndexstartIndex; j--) {
	 			change = false;
	 			if(arrayToBeSorted[j]arrayToBeSorted[k]) {
	 				var temp:int = arrayToBeSorted[k];
	 				arrayToBeSorted[k] = arrayToBeSorted[k-1];
	 				arrayToBeSorted[k-1] = temp;
	 				change = true;
	 			}
	 			tempIndex = k;
	 			trace("重的下沉: " + arrayToBeSorted +" Changed: " + change.toString() + " StrtIndex: " + startIndex + " EndIndex:" + k);
	 		}//end of for
	 		endIndex = tempIndex;
	 		trace("startIndex: " + startIndex + " endIndex: " + endIndex);
	 		trace("双向冒泡排序后: " + arrayToBeSorted);
	 	}//end of while
	 }//end of function

----------Post from: @LiGuoliang.com, 欢迎回来~----------