(CompareTo, Compare,hashCode,equals函数)持有对象与公有比较函数
（一）， int CompareTo(Object o)的介绍
此函数没有缺省值，必须自己定义它。表示调用此函数的对象与传入的另一个对象o做比较，若返回负值（表示此对象小于传入的对象，事实并没有所谓的大小之分）则在数组或容器中将此对象放在传入的对象前面，若返回正值则所放的位置相反，若返回0则不改变位置。
（二）：数组的排序和找查
（二.一）， 对数组进行排序时系统自动调用int CompareTo(Object o)函数的情况
设a是一个储存对象的数组，A是a的一元素；
当使用函数Arrays.sort(a)；来为a排序时，系统就会调用a[0]的intCompareTo(Object o)函数，并且逐一以a[1],a2],a[3]直至a[a.length-1]作为参数输入。因此a[0]调用int CompareTo(Object o)的次数是a.length-1。
同理，a[1]也会以a[2],a3],a[4] 直至a[a.length-1]作为参数调用a[1]的int CompareTo(Object o)函数。同理，a[1]调用int CompareTo(Object o)的次数是a.length-2。依次类推。当然a[1]与a[2]和其他元素调用int CompareTo(Object o)函数是交叉进行的。
（二.二）， 对数组进行排序时对数组元素的要求
系统会将数组的元素向上转型至Compararable, 然后用转型后的对象调用int CompareTo(Object o)。因此数组内的所有元素所在的类必须实现接口Compararable并且复写int CompareTo(Object o)，因此数组也不能有空元素。
（二.三）， 对数组元素进行找查时系统自动调用int CompareTo(Object o)函数的情况
当使用函数Arrays.binarySearch(a,A)；来找查数组a是否存在元素A时，则系统会以A为参数逐一调用从a[0]开始至a[a..length-1]的int CompareTo(Object o)函数，当然若找到A就不再调用。
（二.四）， 对数组进行找查时对数组元素的要求
数组的元素的int CompareTo(Object o)函数必须能够有效地起到比较作用，才能保证能找到目标。比如，每个元素的int CompareTo(Object o)不管任何情况都返回正值的话，那么根据函数Arrays.binarySearch(a,A)自动调用函数int CompareTo(Object o)的流程，可知最终将发生逻辑矛盾（因为，至少，一定会以元素本身作为参数调用本身的int CompareTo(Object o)函数），发生逻辑矛盾就不可能找到目标。
（二.五）， 对数组元素进行找查后的结果
设有三个相同的元素，a[11]=A1,a[12]=A2,a[13]=A3。找查A1时可以得出它的位置是11，找查A2，A3同理得出它的位置是11，因为比较函数int CompareTo(Object o) 相同，输入的参数也相同。所以找查得出的位置的后面才可能有相同元素，前面不可能有相同元素。
（二.六）， 注意int compareTo(Object o)函数内是否有转型动作
int CompareTo(Object o)函数里面通常有转型动作，把o转型。因此数组中如果有多种对象元素且int CompareTo(Object o)函数里面有转型动作就不能用Arrays.sort(Object[] a)和Arrays.binarySearch(Object[] a, Object key)来排序和找查，否则将发生执行期错误。要使用函数 sort(Object [] a,Comparato c)和 Arrays.binarySearch (Object[] a, Object key, Comparato c)。利用函数int compare(Object o1, Object o2)进行元素的排序和找查。
（二.七）， int compare(Object o1, Object o2)的介绍
此函数没有缺省值，必须自己定义它。调用此函数的对象并不做比较，把传入的两个对象o1，o2做比较，若返回负值（表示此o1小于o2，事实并没有所谓的大小之分）则在数组或容器中把o1放在o2的前面，若返回正值则所放的位置相反，若返回0则不改变位置。
（二.八）， 对数组进行排序时系统自动调用int compare(Object o1, Object o2)函数的情况
当使用函数sort(Object [] a,Comparato c)；来为a排序时系统就会调用c的compare(Object o1, Object o2)函数，并且逐一以（a[0],a[1]）, （a[0],a[2]）直至（a[0],a[a.length-1]）作为参数输入。a[0] 作为参数的次数是a.length-1。
同理，c会以（a[1],a[2]）, （a[1],a[2]）直至（a[1],a[a.length-1]）作为参数调用compare(Object o1, Object o2)函数。同理，a[1] 作为参数的次数是a.length-2。依次类推。当然以a[0]与a[1]和其他元素作为第一个参数调用c的compare(Object o1, Object o2)函数是交叉进行的。
（二.九）， 对数组进行找查时对数组元素的要求
因为比较函数是由对象c提供的，因此数组排序时数组内可以有空元素，可以不复写int CompareTo(Object o)函数的元素，有可以有不同的元素，可以是任何对象元素。对数组元素没有任何要求。当然，c的compare(Object o1, Object o2)函数不能对o1,o2进行转型。
（二.十）， 对数组元素进行找查时系统自动调用int compare(Object o1, Object o2)函数的情况
Arrays.binarySearch ( a, A, c)；来找查数组a是否存在元素A时，则系统会以A为第二个参数分别以a[0]至a[a..length-1] 为第一个参数逐一调用c的compare(Object o1, Object o2)函数。当然若找到A就不再调用。
（二.十一）， 对数组进行找查时对数组元素的要求与结果
要求：当然，c的compare(Object o1, Object o2)函数和int CompareTo(Object o)函数一样，必须提供有效的比较方式，才能保证找到目标。
结果：设有三个相同的元素，a[11]=A1,a[12]=A2,a[13]=A3。找查A1时可以得出它的位置是11，找查A2，A3同理得出它的位置是11，因为比较函数compare(Object o1, Object o2)相同，输入的参数也相同。所以找查得出的位置的后面才可能有相同元素，前面不可能有相同元素。
（三）：List排序和找查
Collections和Arrays一样，Arrays为数组提供一些操作函数，Collections就为List和Set提供一些操作函数。但Collections只为List提供元素的排序和找查，因为Set并不需要。
在不排序的情况下，第一加入的元素对应的序列号为0，第二加入的元素对应的序列号为1，依次类推。
对它排序可以使用函数Collections.sort(List list), Collections.sort(List list,Comparato c)。
对它的元素进行找查可以使用函数Collections.binarySearch (List list,Object key), Collections.binarySearch (List list,Object key,Comparato c)。
用sort和binarySearch对List排序和找查和用sort和binarySearch对数组进行排序和找查，程序的要求，过程，结果，完全一模一样。
(三)TreeSet加入对象
intCompareTo(Object o)函数不仅用来确定TreeSet元素的次序，而且用来确定TreeSet元素的独一无二。
TreeSet的一个对象tS,用tS.add(Object o)，加入对象时，系统就会调用加入的对象o的intCompareTo(Object o)函数，并且没有次序地把已经加入的对象作为参数输入。直到确定tS里面元素的次序，然后停止调用o的intCompareTo(Object o)函数。若intCompareTo(Object o)函数返回0值，则不将对象o加入，而不是用o来代替与o相同的对象。
也就是说TreeSet加入对象后，TreeSet里面元素的唯一性和元素的次序就得到了确定。
(四)TreeMap加入对象与取出对象
intCompareTo(Object o)函数不仅用来确定TreeMap的key值次序，而且用来确定key值的独一无二。
TreeMap的一个对象tM,用tM.put(Object key,Object value)，加入对象时，系统就会调用key的intCompareTo(Object o)函数，并且没有次序地把已经加入的键值对象作为参数输入。直到确定tM里面键值对象的次序，然后停止调用key的intCompareTo(Object o)函数。若intCompareTo(Object o)函数返回0值，则将key加入并且加入它对应的value值，代替覆盖与key相同的键值对象和用value值代替它的实值。
用tM.get(Object key)来取它对应的实值时，系统也会调用key的intCompareTo(Object o)函数，并且没有次序地把已经加入的键值对象作为参数输入，用来找查和确定是否有键值和这个key对应，有则调用对应这个key的键值的实值。
(五)，int hashCode()函数的介绍
int hashCode()函数存在每一个类中，表示根据它的返回值产生一个int型整数（即hash code）来代表这个对象。在缺省的状态下，int hashCode()函数会为每一个对象产生一个无二的hash code。若复写int hash code()函数，则系统会根据它的返回值来产生hash code代表对象,不同的的返回值会得到不同的hash code，相同的的返回值会得到相同的hash code不论是否在同一个包中或其他情况，返回值相同hash code则相同,但注意返回值与所得到的hash code的值是不相同的。
(六)，int hashCode()函数的与Stirng toString()函数的关系
当对象转化为字符串时，即用字符串的形式表示对象时(注意不是把它转型成String类)，系统会先自动调用此对象的String toString()函数。缺省的String toString()函数会用“包名+类名+@+hash code”的字符串来代表调用它的对象。所以，设hC是一个对象的话，象这样的动作：String s=""+hC; System.out.println(hC); 系统都会自动先调用hC的String toString()函数，后再调用hC的int hashCode()函数，因为要获取hC的hash code 它的String toString()函数里面会调用hC的int hashCode()函数。即缺省的String toString()函数会调用hC的int hashCode()函数。若复写了String toString()函数，当对象转化为字符串时，就不一定会调用int hashCode()函数了。
(七)，boolean equals(Object obj)函数的介绍
boolean equals(Object obj)函数存在每一个类中，它表示调用此函数的对象与传入的对象obj做比较，若返回true（就说这两个对象相等，事实上除了它本身没有一个对象和它真正相等）则容器就把这两个对象当作同一元素对待。若返回false，则容器就认为这两个对象是两个不同的元素。在缺省的状态下，boolean equals(Object obj)函数除了把调用它的对象作为参数输入会返回true，否则使用其他对象作为参数都会返回false。
(八)，HashSet加入对象
（1），HashSet的一个对象hS,用hS.add(Object o)，加入对象时，由于要确定每个元素的唯一性，系统就会首先自动调用对象o的int hashCode()函数。
（2），然后会把得到的o的hash code值与已经加入容器的对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果将要加入的对象o的hash code值与已经加入的容器里面的任意一个对象的hash code值不同，则将对象o加入容器。
（3），如果有对象的hash code值与o的hash code值相同，则系统会再自动调用0的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象o的hash code值相同的对象作为参数，来进行比较。
（4），如果o的boolean equals(Object obj)函数的所有返回值都是false则将对象o加入容器。
如果返回值出现true,则将对象o代替这时作为boolean equals(Object obj)的参数的对象加入容器，即用o覆盖这时的参数obj。然后终止调用o的boolean equals(Object obj)函数。
如果这些参数中，含有对象o本身，则在对象o作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止o的boolean equals(Object obj)函数的调用，然后不把对象o再次加入容器。
（5），即hS.add(Object o)，加入对象时，要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
(九)HashMap加入对象与取出对象
（1）HashMap加入对象
（1.1），HashMap的一个对象hM, 用hM.put(Object key,Object value)，加入对象时，由于要确定每个key值的唯一性，系统就会首先自动调用对象key的int hashCode()函数。
（1.2），然后会把得到的对象key的hash code值与已经加入容器的键值对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果将要加入的对象key的hash code值与已经加入的容器里面的任意一个键值对象的hash code值不同，则将对象key和value加入容器。
（1.3），如果有键值对象的hash code值与key的hash code值相同，则系统会再自动调用key的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象key的hash code值相同的键值对象作为参数，来进行比较。
（1.4），如果key的boolean equals(Object obj)函数的所有返回值都是false则将对象key和value加入容器。
如果返回值出现true,则将对象key代替这时作为boolean equals(Object obj)的参数的键值对象加入容器，即用key覆盖这时的参数obj，然后用key对应的实值value覆盖此时的obj对应的实值。最后终止调用key的boolean equals(Object obj)函数。
如果这些参数中，含有对象key本身，则在对象key作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止o的boolean equals(Object obj)函数的调用，然后键值保持不变用新实值覆盖旧覆盖。
（1.5），即hM.put(Object key,Object value)，加入对象时，要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
（2）HashMap取出对象
（2.1），HashMap的一个对象hM, hM.get(Object key)来取它对应的实值时，由于要确定容器内是否有键值和这个key对应，，系统就会首先自动调用对象key的int hashCode()函数。
（2.2），然后会把得到的对象key的hash code值与已经加入容器的键值对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果对象key的hash code值与已经加入的容器里面的任意一个键值对象的hash code值不同，则容器内没有与key对应的键值，取出的值是null。
（2.3），如果有键值对象的hash code值与key的hash code值相同，则系统会再自动调用key的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象key的hash code值相同的键值对象作为参数，来进行比较。
（2.4），如果key的boolean equals(Object obj)函数的所有返回值都是false则容器内没有与key对应的键值，取出的值是null。。
如果返回值出现true,则取出此时作为boolean equals(Object obj)的参数的键值对象所对应的实值。然后终止调用key的boolean equals(Object obj)函数。
如果这些参数中，含有对象key本身，则在对象key作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止key的boolean equals(Object obj)函数的调用，并取出key对应的实值。
（2.5）, 要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
最后：知道这些过程就能有效的定义这些函数了。哈哈！
吉林大学珠海学院2004级计算机系：才哥，E_Mail:eattea@21cn.com,QQ:398415441。联系我！！！
（学习时间有限，有错误的话请见谅！！！）88L
(CompareTo, Compare,hashCode,equals函数)持有对象与公有比较函数
（一）， int CompareTo(Object o)的介绍
此函数没有缺省值，必须自己定义它。表示调用此函数的对象与传入的另一个对象o做比较，若返回负值（表示此对象小于传入的对象，事实并没有所谓的大小之分）则在数组或容器中将此对象放在传入的对象前面，若返回正值则所放的位置相反，若返回0则不改变位置。
（二）：数组的排序和找查
（二.一）， 对数组进行排序时系统自动调用int CompareTo(Object o)函数的情况
设a是一个储存对象的数组，A是a的一元素；
当使用函数Arrays.sort(a)；来为a排序时，系统就会调用a[0]的intCompareTo(Object o)函数，并且逐一以a[1],a2],a[3]直至a[a.length-1]作为参数输入。因此a[0]调用int CompareTo(Object o)的次数是a.length-1。
同理，a[1]也会以a[2],a3],a[4] 直至a[a.length-1]作为参数调用a[1]的int CompareTo(Object o)函数。同理，a[1]调用int CompareTo(Object o)的次数是a.length-2。依次类推。当然a[1]与a[2]和其他元素调用int CompareTo(Object o)函数是交叉进行的。
（二.二）， 对数组进行排序时对数组元素的要求
系统会将数组的元素向上转型至Compararable, 然后用转型后的对象调用int CompareTo(Object o)。因此数组内的所有元素所在的类必须实现接口Compararable并且复写int CompareTo(Object o)，因此数组也不能有空元素。
（二.三）， 对数组元素进行找查时系统自动调用int CompareTo(Object o)函数的情况
当使用函数Arrays.binarySearch(a,A)；来找查数组a是否存在元素A时，则系统会以A为参数逐一调用从a[0]开始至a[a..length-1]的int CompareTo(Object o)函数，当然若找到A就不再调用。
（二.四）， 对数组进行找查时对数组元素的要求
数组的元素的int CompareTo(Object o)函数必须能够有效地起到比较作用，才能保证能找到目标。比如，每个元素的int CompareTo(Object o)不管任何情况都返回正值的话，那么根据函数Arrays.binarySearch(a,A)自动调用函数int CompareTo(Object o)的流程，可知最终将发生逻辑矛盾（因为，至少，一定会以元素本身作为参数调用本身的int CompareTo(Object o)函数），发生逻辑矛盾就不可能找到目标。
（二.五）， 对数组元素进行找查后的结果
设有三个相同的元素，a[11]=A1,a[12]=A2,a[13]=A3。找查A1时可以得出它的位置是11，找查A2，A3同理得出它的位置是11，因为比较函数int CompareTo(Object o) 相同，输入的参数也相同。所以找查得出的位置的后面才可能有相同元素，前面不可能有相同元素。
（二.六）， 注意int compareTo(Object o)函数内是否有转型动作
int CompareTo(Object o)函数里面通常有转型动作，把o转型。因此数组中如果有多种对象元素且int CompareTo(Object o)函数里面有转型动作就不能用Arrays.sort(Object[] a)和Arrays.binarySearch(Object[] a, Object key)来排序和找查，否则将发生执行期错误。要使用函数 sort(Object [] a,Comparato c)和 Arrays.binarySearch (Object[] a, Object key, Comparato c)。利用函数int compare(Object o1, Object o2)进行元素的排序和找查。
（二.七）， int compare(Object o1, Object o2)的介绍
此函数没有缺省值，必须自己定义它。调用此函数的对象并不做比较，把传入的两个对象o1，o2做比较，若返回负值（表示此o1小于o2，事实并没有所谓的大小之分）则在数组或容器中把o1放在o2的前面，若返回正值则所放的位置相反，若返回0则不改变位置。
（二.八）， 对数组进行排序时系统自动调用int compare(Object o1, Object o2)函数的情况
当使用函数sort(Object [] a,Comparato c)；来为a排序时系统就会调用c的compare(Object o1, Object o2)函数，并且逐一以（a[0],a[1]）, （a[0],a[2]）直至（a[0],a[a.length-1]）作为参数输入。a[0] 作为参数的次数是a.length-1。
同理，c会以（a[1],a[2]）, （a[1],a[2]）直至（a[1],a[a.length-1]）作为参数调用compare(Object o1, Object o2)函数。同理，a[1] 作为参数的次数是a.length-2。依次类推。当然以a[0]与a[1]和其他元素作为第一个参数调用c的compare(Object o1, Object o2)函数是交叉进行的。
（二.九）， 对数组进行找查时对数组元素的要求
因为比较函数是由对象c提供的，因此数组排序时数组内可以有空元素，可以不复写int CompareTo(Object o)函数的元素，有可以有不同的元素，可以是任何对象元素。对数组元素没有任何要求。当然，c的compare(Object o1, Object o2)函数不能对o1,o2进行转型。
（二.十）， 对数组元素进行找查时系统自动调用int compare(Object o1, Object o2)函数的情况
Arrays.binarySearch ( a, A, c)；来找查数组a是否存在元素A时，则系统会以A为第二个参数分别以a[0]至a[a..length-1] 为第一个参数逐一调用c的compare(Object o1, Object o2)函数。当然若找到A就不再调用。
（二.十一）， 对数组进行找查时对数组元素的要求与结果
要求：当然，c的compare(Object o1, Object o2)函数和int CompareTo(Object o)函数一样，必须提供有效的比较方式，才能保证找到目标。
结果：设有三个相同的元素，a[11]=A1,a[12]=A2,a[13]=A3。找查A1时可以得出它的位置是11，找查A2，A3同理得出它的位置是11，因为比较函数compare(Object o1, Object o2)相同，输入的参数也相同。所以找查得出的位置的后面才可能有相同元素，前面不可能有相同元素。
（三）：List排序和找查
Collections和Arrays一样，Arrays为数组提供一些操作函数，Collections就为List和Set提供一些操作函数。但Collections只为List提供元素的排序和找查，因为Set并不需要。
在不排序的情况下，第一加入的元素对应的序列号为0，第二加入的元素对应的序列号为1，依次类推。
对它排序可以使用函数Collections.sort(List list), Collections.sort(List list,Comparato c)。
对它的元素进行找查可以使用函数Collections.binarySearch (List list,Object key), Collections.binarySearch (List list,Object key,Comparato c)。
用sort和binarySearch对List排序和找查和用sort和binarySearch对数组进行排序和找查，程序的要求，过程，结果，完全一模一样。
(三)TreeSet加入对象
intCompareTo(Object o)函数不仅用来确定TreeSet元素的次序，而且用来确定TreeSet元素的独一无二。
TreeSet的一个对象tS,用tS.add(Object o)，加入对象时，系统就会调用加入的对象o的intCompareTo(Object o)函数，并且没有次序地把已经加入的对象作为参数输入。直到确定tS里面元素的次序，然后停止调用o的intCompareTo(Object o)函数。若intCompareTo(Object o)函数返回0值，则不将对象o加入，而不是用o来代替与o相同的对象。
也就是说TreeSet加入对象后，TreeSet里面元素的唯一性和元素的次序就得到了确定。
(四)TreeMap加入对象与取出对象
intCompareTo(Object o)函数不仅用来确定TreeMap的key值次序，而且用来确定key值的独一无二。
TreeMap的一个对象tM,用tM.put(Object key,Object value)，加入对象时，系统就会调用key的intCompareTo(Object o)函数，并且没有次序地把已经加入的键值对象作为参数输入。直到确定tM里面键值对象的次序，然后停止调用key的intCompareTo(Object o)函数。若intCompareTo(Object o)函数返回0值，则将key加入并且加入它对应的value值，代替覆盖与key相同的键值对象和用value值代替它的实值。
用tM.get(Object key)来取它对应的实值时，系统也会调用key的intCompareTo(Object o)函数，并且没有次序地把已经加入的键值对象作为参数输入，用来找查和确定是否有键值和这个key对应，有则调用对应这个key的键值的实值。
(五)，int hashCode()函数的介绍
int hashCode()函数存在每一个类中，表示根据它的返回值产生一个int型整数（即hash code）来代表这个对象。在缺省的状态下，int hashCode()函数会为每一个对象产生一个无二的hash code。若复写int hash code()函数，则系统会根据它的返回值来产生hash code代表对象,不同的的返回值会得到不同的hash code，相同的的返回值会得到相同的hash code不论是否在同一个包中或其他情况，返回值相同hash code则相同,但注意返回值与所得到的hash code的值是不相同的。
(六)，int hashCode()函数的与Stirng toString()函数的关系
当对象转化为字符串时，即用字符串的形式表示对象时(注意不是把它转型成String类)，系统会先自动调用此对象的String toString()函数。缺省的String toString()函数会用“包名+类名+@+hash code”的字符串来代表调用它的对象。所以，设hC是一个对象的话，象这样的动作：String s=""+hC; System.out.println(hC); 系统都会自动先调用hC的String toString()函数，后再调用hC的int hashCode()函数，因为要获取hC的hash code 它的String toString()函数里面会调用hC的int hashCode()函数。即缺省的String toString()函数会调用hC的int hashCode()函数。若复写了String toString()函数，当对象转化为字符串时，就不一定会调用int hashCode()函数了。
(七)，boolean equals(Object obj)函数的介绍
boolean equals(Object obj)函数存在每一个类中，它表示调用此函数的对象与传入的对象obj做比较，若返回true（就说这两个对象相等，事实上除了它本身没有一个对象和它真正相等）则容器就把这两个对象当作同一元素对待。若返回false，则容器就认为这两个对象是两个不同的元素。在缺省的状态下，boolean equals(Object obj)函数除了把调用它的对象作为参数输入会返回true，否则使用其他对象作为参数都会返回false。
(八)，HashSet加入对象
（1），HashSet的一个对象hS,用hS.add(Object o)，加入对象时，由于要确定每个元素的唯一性，系统就会首先自动调用对象o的int hashCode()函数。
（2），然后会把得到的o的hash code值与已经加入容器的对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果将要加入的对象o的hash code值与已经加入的容器里面的任意一个对象的hash code值不同，则将对象o加入容器。
（3），如果有对象的hash code值与o的hash code值相同，则系统会再自动调用0的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象o的hash code值相同的对象作为参数，来进行比较。
（4），如果o的boolean equals(Object obj)函数的所有返回值都是false则将对象o加入容器。
如果返回值出现true,则将对象o代替这时作为boolean equals(Object obj)的参数的对象加入容器，即用o覆盖这时的参数obj。然后终止调用o的boolean equals(Object obj)函数。
如果这些参数中，含有对象o本身，则在对象o作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止o的boolean equals(Object obj)函数的调用，然后不把对象o再次加入容器。
（5），即hS.add(Object o)，加入对象时，要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
(九)HashMap加入对象与取出对象
（1）HashMap加入对象
（1.1），HashMap的一个对象hM, 用hM.put(Object key,Object value)，加入对象时，由于要确定每个key值的唯一性，系统就会首先自动调用对象key的int hashCode()函数。
（1.2），然后会把得到的对象key的hash code值与已经加入容器的键值对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果将要加入的对象key的hash code值与已经加入的容器里面的任意一个键值对象的hash code值不同，则将对象key和value加入容器。
（1.3），如果有键值对象的hash code值与key的hash code值相同，则系统会再自动调用key的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象key的hash code值相同的键值对象作为参数，来进行比较。
（1.4），如果key的boolean equals(Object obj)函数的所有返回值都是false则将对象key和value加入容器。
如果返回值出现true,则将对象key代替这时作为boolean equals(Object obj)的参数的键值对象加入容器，即用key覆盖这时的参数obj，然后用key对应的实值value覆盖此时的obj对应的实值。最后终止调用key的boolean equals(Object obj)函数。
如果这些参数中，含有对象key本身，则在对象key作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止o的boolean equals(Object obj)函数的调用，然后键值保持不变用新实值覆盖旧覆盖。
（1.5），即hM.put(Object key,Object value)，加入对象时，要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
（2）HashMap取出对象
（2.1），HashMap的一个对象hM, hM.get(Object key)来取它对应的实值时，由于要确定容器内是否有键值和这个key对应，，系统就会首先自动调用对象key的int hashCode()函数。
（2.2），然后会把得到的对象key的hash code值与已经加入容器的键值对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果对象key的hash code值与已经加入的容器里面的任意一个键值对象的hash code值不同，则容器内没有与key对应的键值，取出的值是null。
（2.3），如果有键值对象的hash code值与key的hash code值相同，则系统会再自动调用key的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象key的hash code值相同的键值对象作为参数，来进行比较。
（2.4），如果key的boolean equals(Object obj)函数的所有返回值都是false则容器内没有与key对应的键值，取出的值是null。。
如果返回值出现true,则取出此时作为boolean equals(Object obj)的参数的键值对象所对应的实值。然后终止调用key的boolean equals(Object obj)函数。
如果这些参数中，含有对象key本身，则在对象key作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止key的boolean equals(Object obj)函数的调用，并取出key对应的实值。
（2.5）, 要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
最后：知道这些过程就能有效的定义这些函数了。哈哈！
吉林大学珠海学院2004级计算机系：才哥，E_Mail:eattea@21cn.com,QQ:398415441。联系我！！！
（学习时间有限，有错误的话请见谅！！！）88L
(CompareTo, Compare,hashCode,equals函数)持有对象与公有比较函数
（一）， int CompareTo(Object o)的介绍
此函数没有缺省值，必须自己定义它。表示调用此函数的对象与传入的另一个对象o做比较，若返回负值（表示此对象小于传入的对象，事实并没有所谓的大小之分）则在数组或容器中将此对象放在传入的对象前面，若返回正值则所放的位置相反，若返回0则不改变位置。
（二）：数组的排序和找查
（二.一）， 对数组进行排序时系统自动调用int CompareTo(Object o)函数的情况
设a是一个储存对象的数组，A是a的一元素；
当使用函数Arrays.sort(a)；来为a排序时，系统就会调用a[0]的intCompareTo(Object o)函数，并且逐一以a[1],a2],a[3]直至a[a.length-1]作为参数输入。因此a[0]调用int CompareTo(Object o)的次数是a.length-1。
同理，a[1]也会以a[2],a3],a[4] 直至a[a.length-1]作为参数调用a[1]的int CompareTo(Object o)函数。同理，a[1]调用int CompareTo(Object o)的次数是a.length-2。依次类推。当然a[1]与a[2]和其他元素调用int CompareTo(Object o)函数是交叉进行的。
（二.二）， 对数组进行排序时对数组元素的要求
系统会将数组的元素向上转型至Compararable, 然后用转型后的对象调用int CompareTo(Object o)。因此数组内的所有元素所在的类必须实现接口Compararable并且复写int CompareTo(Object o)，因此数组也不能有空元素。
（二.三）， 对数组元素进行找查时系统自动调用int CompareTo(Object o)函数的情况
当使用函数Arrays.binarySearch(a,A)；来找查数组a是否存在元素A时，则系统会以A为参数逐一调用从a[0]开始至a[a..length-1]的int CompareTo(Object o)函数，当然若找到A就不再调用。
（二.四）， 对数组进行找查时对数组元素的要求
数组的元素的int CompareTo(Object o)函数必须能够有效地起到比较作用，才能保证能找到目标。比如，每个元素的int CompareTo(Object o)不管任何情况都返回正值的话，那么根据函数Arrays.binarySearch(a,A)自动调用函数int CompareTo(Object o)的流程，可知最终将发生逻辑矛盾（因为，至少，一定会以元素本身作为参数调用本身的int CompareTo(Object o)函数），发生逻辑矛盾就不可能找到目标。
（二.五）， 对数组元素进行找查后的结果
设有三个相同的元素，a[11]=A1,a[12]=A2,a[13]=A3。找查A1时可以得出它的位置是11，找查A2，A3同理得出它的位置是11，因为比较函数int CompareTo(Object o) 相同，输入的参数也相同。所以找查得出的位置的后面才可能有相同元素，前面不可能有相同元素。
（二.六）， 注意int compareTo(Object o)函数内是否有转型动作
int CompareTo(Object o)函数里面通常有转型动作，把o转型。因此数组中如果有多种对象元素且int CompareTo(Object o)函数里面有转型动作就不能用Arrays.sort(Object[] a)和Arrays.binarySearch(Object[] a, Object key)来排序和找查，否则将发生执行期错误。要使用函数 sort(Object [] a,Comparato c)和 Arrays.binarySearch (Object[] a, Object key, Comparato c)。利用函数int compare(Object o1, Object o2)进行元素的排序和找查。
（二.七）， int compare(Object o1, Object o2)的介绍
此函数没有缺省值，必须自己定义它。调用此函数的对象并不做比较，把传入的两个对象o1，o2做比较，若返回负值（表示此o1小于o2，事实并没有所谓的大小之分）则在数组或容器中把o1放在o2的前面，若返回正值则所放的位置相反，若返回0则不改变位置。
（二.八）， 对数组进行排序时系统自动调用int compare(Object o1, Object o2)函数的情况
当使用函数sort(Object [] a,Comparato c)；来为a排序时系统就会调用c的compare(Object o1, Object o2)函数，并且逐一以（a[0],a[1]）, （a[0],a[2]）直至（a[0],a[a.length-1]）作为参数输入。a[0] 作为参数的次数是a.length-1。
同理，c会以（a[1],a[2]）, （a[1],a[2]）直至（a[1],a[a.length-1]）作为参数调用compare(Object o1, Object o2)函数。同理，a[1] 作为参数的次数是a.length-2。依次类推。当然以a[0]与a[1]和其他元素作为第一个参数调用c的compare(Object o1, Object o2)函数是交叉进行的。
（二.九）， 对数组进行找查时对数组元素的要求
因为比较函数是由对象c提供的，因此数组排序时数组内可以有空元素，可以不复写int CompareTo(Object o)函数的元素，有可以有不同的元素，可以是任何对象元素。对数组元素没有任何要求。当然，c的compare(Object o1, Object o2)函数不能对o1,o2进行转型。
（二.十）， 对数组元素进行找查时系统自动调用int compare(Object o1, Object o2)函数的情况
Arrays.binarySearch ( a, A, c)；来找查数组a是否存在元素A时，则系统会以A为第二个参数分别以a[0]至a[a..length-1] 为第一个参数逐一调用c的compare(Object o1, Object o2)函数。当然若找到A就不再调用。
（二.十一）， 对数组进行找查时对数组元素的要求与结果
要求：当然，c的compare(Object o1, Object o2)函数和int CompareTo(Object o)函数一样，必须提供有效的比较方式，才能保证找到目标。
结果：设有三个相同的元素，a[11]=A1,a[12]=A2,a[13]=A3。找查A1时可以得出它的位置是11，找查A2，A3同理得出它的位置是11，因为比较函数compare(Object o1, Object o2)相同，输入的参数也相同。所以找查得出的位置的后面才可能有相同元素，前面不可能有相同元素。
（三）：List排序和找查
Collections和Arrays一样，Arrays为数组提供一些操作函数，Collections就为List和Set提供一些操作函数。但Collections只为List提供元素的排序和找查，因为Set并不需要。
在不排序的情况下，第一加入的元素对应的序列号为0，第二加入的元素对应的序列号为1，依次类推。
对它排序可以使用函数Collections.sort(List list), Collections.sort(List list,Comparato c)。
对它的元素进行找查可以使用函数Collections.binarySearch (List list,Object key), Collections.binarySearch (List list,Object key,Comparato c)。
用sort和binarySearch对List排序和找查和用sort和binarySearch对数组进行排序和找查，程序的要求，过程，结果，完全一模一样。
(三)TreeSet加入对象
intCompareTo(Object o)函数不仅用来确定TreeSet元素的次序，而且用来确定TreeSet元素的独一无二。
TreeSet的一个对象tS,用tS.add(Object o)，加入对象时，系统就会调用加入的对象o的intCompareTo(Object o)函数，并且没有次序地把已经加入的对象作为参数输入。直到确定tS里面元素的次序，然后停止调用o的intCompareTo(Object o)函数。若intCompareTo(Object o)函数返回0值，则不将对象o加入，而不是用o来代替与o相同的对象。
也就是说TreeSet加入对象后，TreeSet里面元素的唯一性和元素的次序就得到了确定。
(四)TreeMap加入对象与取出对象
intCompareTo(Object o)函数不仅用来确定TreeMap的key值次序，而且用来确定key值的独一无二。
TreeMap的一个对象tM,用tM.put(Object key,Object value)，加入对象时，系统就会调用key的intCompareTo(Object o)函数，并且没有次序地把已经加入的键值对象作为参数输入。直到确定tM里面键值对象的次序，然后停止调用key的intCompareTo(Object o)函数。若intCompareTo(Object o)函数返回0值，则将key加入并且加入它对应的value值，代替覆盖与key相同的键值对象和用value值代替它的实值。
用tM.get(Object key)来取它对应的实值时，系统也会调用key的intCompareTo(Object o)函数，并且没有次序地把已经加入的键值对象作为参数输入，用来找查和确定是否有键值和这个key对应，有则调用对应这个key的键值的实值。
(五)，int hashCode()函数的介绍
int hashCode()函数存在每一个类中，表示根据它的返回值产生一个int型整数（即hash code）来代表这个对象。在缺省的状态下，int hashCode()函数会为每一个对象产生一个无二的hash code。若复写int hash code()函数，则系统会根据它的返回值来产生hash code代表对象,不同的的返回值会得到不同的hash code，相同的的返回值会得到相同的hash code不论是否在同一个包中或其他情况，返回值相同hash code则相同,但注意返回值与所得到的hash code的值是不相同的。
(六)，int hashCode()函数的与Stirng toString()函数的关系
当对象转化为字符串时，即用字符串的形式表示对象时(注意不是把它转型成String类)，系统会先自动调用此对象的String toString()函数。缺省的String toString()函数会用“包名+类名+@+hash code”的字符串来代表调用它的对象。所以，设hC是一个对象的话，象这样的动作：String s=""+hC; System.out.println(hC); 系统都会自动先调用hC的String toString()函数，后再调用hC的int hashCode()函数，因为要获取hC的hash code 它的String toString()函数里面会调用hC的int hashCode()函数。即缺省的String toString()函数会调用hC的int hashCode()函数。若复写了String toString()函数，当对象转化为字符串时，就不一定会调用int hashCode()函数了。
(七)，boolean equals(Object obj)函数的介绍
boolean equals(Object obj)函数存在每一个类中，它表示调用此函数的对象与传入的对象obj做比较，若返回true（就说这两个对象相等，事实上除了它本身没有一个对象和它真正相等）则容器就把这两个对象当作同一元素对待。若返回false，则容器就认为这两个对象是两个不同的元素。在缺省的状态下，boolean equals(Object obj)函数除了把调用它的对象作为参数输入会返回true，否则使用其他对象作为参数都会返回false。
(八)，HashSet加入对象
（1），HashSet的一个对象hS,用hS.add(Object o)，加入对象时，由于要确定每个元素的唯一性，系统就会首先自动调用对象o的int hashCode()函数。
（2），然后会把得到的o的hash code值与已经加入容器的对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果将要加入的对象o的hash code值与已经加入的容器里面的任意一个对象的hash code值不同，则将对象o加入容器。
（3），如果有对象的hash code值与o的hash code值相同，则系统会再自动调用0的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象o的hash code值相同的对象作为参数，来进行比较。
（4），如果o的boolean equals(Object obj)函数的所有返回值都是false则将对象o加入容器。
如果返回值出现true,则将对象o代替这时作为boolean equals(Object obj)的参数的对象加入容器，即用o覆盖这时的参数obj。然后终止调用o的boolean equals(Object obj)函数。
如果这些参数中，含有对象o本身，则在对象o作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止o的boolean equals(Object obj)函数的调用，然后不把对象o再次加入容器。
（5），即hS.add(Object o)，加入对象时，要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
(九)HashMap加入对象与取出对象
（1）HashMap加入对象
（1.1），HashMap的一个对象hM, 用hM.put(Object key,Object value)，加入对象时，由于要确定每个key值的唯一性，系统就会首先自动调用对象key的int hashCode()函数。
（1.2），然后会把得到的对象key的hash code值与已经加入容器的键值对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果将要加入的对象key的hash code值与已经加入的容器里面的任意一个键值对象的hash code值不同，则将对象key和value加入容器。
（1.3），如果有键值对象的hash code值与key的hash code值相同，则系统会再自动调用key的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象key的hash code值相同的键值对象作为参数，来进行比较。
（1.4），如果key的boolean equals(Object obj)函数的所有返回值都是false则将对象key和value加入容器。
如果返回值出现true,则将对象key代替这时作为boolean equals(Object obj)的参数的键值对象加入容器，即用key覆盖这时的参数obj，然后用key对应的实值value覆盖此时的obj对应的实值。最后终止调用key的boolean equals(Object obj)函数。
如果这些参数中，含有对象key本身，则在对象key作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止o的boolean equals(Object obj)函数的调用，然后键值保持不变用新实值覆盖旧覆盖。
（1.5），即hM.put(Object key,Object value)，加入对象时，要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
（2）HashMap取出对象
（2.1），HashMap的一个对象hM, hM.get(Object key)来取它对应的实值时，由于要确定容器内是否有键值和这个key对应，，系统就会首先自动调用对象key的int hashCode()函数。
（2.2），然后会把得到的对象key的hash code值与已经加入容器的键值对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果对象key的hash code值与已经加入的容器里面的任意一个键值对象的hash code值不同，则容器内没有与key对应的键值，取出的值是null。
（2.3），如果有键值对象的hash code值与key的hash code值相同，则系统会再自动调用key的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象key的hash code值相同的键值对象作为参数，来进行比较。
（2.4），如果key的boolean equals(Object obj)函数的所有返回值都是false则容器内没有与key对应的键值，取出的值是null。。
如果返回值出现true,则取出此时作为boolean equals(Object obj)的参数的键值对象所对应的实值。然后终止调用key的boolean equals(Object obj)函数。
如果这些参数中，含有对象key本身，则在对象key作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止key的boolean equals(Object obj)函数的调用，并取出key对应的实值。
（2.5）, 要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
最后：知道这些过程就能有效的定义这些函数了。哈哈！
吉林大学珠海学院2004级计算机系：才哥，E_Mail:eattea@21cn.com,QQ:398415441。联系我！！！
（学习时间有限，有错误的话请见谅！！！）88L
(CompareTo, Compare,hashCode,equals函数)持有对象与公有比较函数
（一）， int CompareTo(Object o)的介绍
此函数没有缺省值，必须自己定义它。表示调用此函数的对象与传入的另一个对象o做比较，若返回负值（表示此对象小于传入的对象，事实并没有所谓的大小之分）则在数组或容器中将此对象放在传入的对象前面，若返回正值则所放的位置相反，若返回0则不改变位置。
（二）：数组的排序和找查
（二.一）， 对数组进行排序时系统自动调用int CompareTo(Object o)函数的情况
设a是一个储存对象的数组，A是a的一元素；
当使用函数Arrays.sort(a)；来为a排序时，系统就会调用a[0]的intCompareTo(Object o)函数，并且逐一以a[1],a2],a[3]直至a[a.length-1]作为参数输入。因此a[0]调用int CompareTo(Object o)的次数是a.length-1。
同理，a[1]也会以a[2],a3],a[4] 直至a[a.length-1]作为参数调用a[1]的int CompareTo(Object o)函数。同理，a[1]调用int CompareTo(Object o)的次数是a.length-2。依次类推。当然a[1]与a[2]和其他元素调用int CompareTo(Object o)函数是交叉进行的。
（二.二）， 对数组进行排序时对数组元素的要求
系统会将数组的元素向上转型至Compararable, 然后用转型后的对象调用int CompareTo(Object o)。因此数组内的所有元素所在的类必须实现接口Compararable并且复写int CompareTo(Object o)，因此数组也不能有空元素。
（二.三）， 对数组元素进行找查时系统自动调用int CompareTo(Object o)函数的情况
当使用函数Arrays.binarySearch(a,A)；来找查数组a是否存在元素A时，则系统会以A为参数逐一调用从a[0]开始至a[a..length-1]的int CompareTo(Object o)函数，当然若找到A就不再调用。
（二.四）， 对数组进行找查时对数组元素的要求
数组的元素的int CompareTo(Object o)函数必须能够有效地起到比较作用，才能保证能找到目标。比如，每个元素的int CompareTo(Object o)不管任何情况都返回正值的话，那么根据函数Arrays.binarySearch(a,A)自动调用函数int CompareTo(Object o)的流程，可知最终将发生逻辑矛盾（因为，至少，一定会以元素本身作为参数调用本身的int CompareTo(Object o)函数），发生逻辑矛盾就不可能找到目标。
（二.五）， 对数组元素进行找查后的结果
设有三个相同的元素，a[11]=A1,a[12]=A2,a[13]=A3。找查A1时可以得出它的位置是11，找查A2，A3同理得出它的位置是11，因为比较函数int CompareTo(Object o) 相同，输入的参数也相同。所以找查得出的位置的后面才可能有相同元素，前面不可能有相同元素。
（二.六）， 注意int compareTo(Object o)函数内是否有转型动作
int CompareTo(Object o)函数里面通常有转型动作，把o转型。因此数组中如果有多种对象元素且int CompareTo(Object o)函数里面有转型动作就不能用Arrays.sort(Object[] a)和Arrays.binarySearch(Object[] a, Object key)来排序和找查，否则将发生执行期错误。要使用函数 sort(Object [] a,Comparato c)和 Arrays.binarySearch (Object[] a, Object key, Comparato c)。利用函数int compare(Object o1, Object o2)进行元素的排序和找查。
（二.七）， int compare(Object o1, Object o2)的介绍
此函数没有缺省值，必须自己定义它。调用此函数的对象并不做比较，把传入的两个对象o1，o2做比较，若返回负值（表示此o1小于o2，事实并没有所谓的大小之分）则在数组或容器中把o1放在o2的前面，若返回正值则所放的位置相反，若返回0则不改变位置。
（二.八）， 对数组进行排序时系统自动调用int compare(Object o1, Object o2)函数的情况
当使用函数sort(Object [] a,Comparato c)；来为a排序时系统就会调用c的compare(Object o1, Object o2)函数，并且逐一以（a[0],a[1]）, （a[0],a[2]）直至（a[0],a[a.length-1]）作为参数输入。a[0] 作为参数的次数是a.length-1。
同理，c会以（a[1],a[2]）, （a[1],a[2]）直至（a[1],a[a.length-1]）作为参数调用compare(Object o1, Object o2)函数。同理，a[1] 作为参数的次数是a.length-2。依次类推。当然以a[0]与a[1]和其他元素作为第一个参数调用c的compare(Object o1, Object o2)函数是交叉进行的。
（二.九）， 对数组进行找查时对数组元素的要求
因为比较函数是由对象c提供的，因此数组排序时数组内可以有空元素，可以不复写int CompareTo(Object o)函数的元素，有可以有不同的元素，可以是任何对象元素。对数组元素没有任何要求。当然，c的compare(Object o1, Object o2)函数不能对o1,o2进行转型。
（二.十）， 对数组元素进行找查时系统自动调用int compare(Object o1, Object o2)函数的情况
Arrays.binarySearch ( a, A, c)；来找查数组a是否存在元素A时，则系统会以A为第二个参数分别以a[0]至a[a..length-1] 为第一个参数逐一调用c的compare(Object o1, Object o2)函数。当然若找到A就不再调用。
（二.十一）， 对数组进行找查时对数组元素的要求与结果
要求：当然，c的compare(Object o1, Object o2)函数和int CompareTo(Object o)函数一样，必须提供有效的比较方式，才能保证找到目标。
结果：设有三个相同的元素，a[11]=A1,a[12]=A2,a[13]=A3。找查A1时可以得出它的位置是11，找查A2，A3同理得出它的位置是11，因为比较函数compare(Object o1, Object o2)相同，输入的参数也相同。所以找查得出的位置的后面才可能有相同元素，前面不可能有相同元素。
（三）：List排序和找查
Collections和Arrays一样，Arrays为数组提供一些操作函数，Collections就为List和Set提供一些操作函数。但Collections只为List提供元素的排序和找查，因为Set并不需要。
在不排序的情况下，第一加入的元素对应的序列号为0，第二加入的元素对应的序列号为1，依次类推。
对它排序可以使用函数Collections.sort(List list), Collections.sort(List list,Comparato c)。
对它的元素进行找查可以使用函数Collections.binarySearch (List list,Object key), Collections.binarySearch (List list,Object key,Comparato c)。
用sort和binarySearch对List排序和找查和用sort和binarySearch对数组进行排序和找查，程序的要求，过程，结果，完全一模一样。
(三)TreeSet加入对象
intCompareTo(Object o)函数不仅用来确定TreeSet元素的次序，而且用来确定TreeSet元素的独一无二。
TreeSet的一个对象tS,用tS.add(Object o)，加入对象时，系统就会调用加入的对象o的intCompareTo(Object o)函数，并且没有次序地把已经加入的对象作为参数输入。直到确定tS里面元素的次序，然后停止调用o的intCompareTo(Object o)函数。若intCompareTo(Object o)函数返回0值，则不将对象o加入，而不是用o来代替与o相同的对象。
也就是说TreeSet加入对象后，TreeSet里面元素的唯一性和元素的次序就得到了确定。
(四)TreeMap加入对象与取出对象
intCompareTo(Object o)函数不仅用来确定TreeMap的key值次序，而且用来确定key值的独一无二。
TreeMap的一个对象tM,用tM.put(Object key,Object value)，加入对象时，系统就会调用key的intCompareTo(Object o)函数，并且没有次序地把已经加入的键值对象作为参数输入。直到确定tM里面键值对象的次序，然后停止调用key的intCompareTo(Object o)函数。若intCompareTo(Object o)函数返回0值，则将key加入并且加入它对应的value值，代替覆盖与key相同的键值对象和用value值代替它的实值。
用tM.get(Object key)来取它对应的实值时，系统也会调用key的intCompareTo(Object o)函数，并且没有次序地把已经加入的键值对象作为参数输入，用来找查和确定是否有键值和这个key对应，有则调用对应这个key的键值的实值。
(五)，int hashCode()函数的介绍
int hashCode()函数存在每一个类中，表示根据它的返回值产生一个int型整数（即hash code）来代表这个对象。在缺省的状态下，int hashCode()函数会为每一个对象产生一个无二的hash code。若复写int hash code()函数，则系统会根据它的返回值来产生hash code代表对象,不同的的返回值会得到不同的hash code，相同的的返回值会得到相同的hash code不论是否在同一个包中或其他情况，返回值相同hash code则相同,但注意返回值与所得到的hash code的值是不相同的。
(六)，int hashCode()函数的与Stirng toString()函数的关系
当对象转化为字符串时，即用字符串的形式表示对象时(注意不是把它转型成String类)，系统会先自动调用此对象的String toString()函数。缺省的String toString()函数会用“包名+类名+@+hash code”的字符串来代表调用它的对象。所以，设hC是一个对象的话，象这样的动作：String s=""+hC; System.out.println(hC); 系统都会自动先调用hC的String toString()函数，后再调用hC的int hashCode()函数，因为要获取hC的hash code 它的String toString()函数里面会调用hC的int hashCode()函数。即缺省的String toString()函数会调用hC的int hashCode()函数。若复写了String toString()函数，当对象转化为字符串时，就不一定会调用int hashCode()函数了。
(七)，boolean equals(Object obj)函数的介绍
boolean equals(Object obj)函数存在每一个类中，它表示调用此函数的对象与传入的对象obj做比较，若返回true（就说这两个对象相等，事实上除了它本身没有一个对象和它真正相等）则容器就把这两个对象当作同一元素对待。若返回false，则容器就认为这两个对象是两个不同的元素。在缺省的状态下，boolean equals(Object obj)函数除了把调用它的对象作为参数输入会返回true，否则使用其他对象作为参数都会返回false。
(八)，HashSet加入对象
（1），HashSet的一个对象hS,用hS.add(Object o)，加入对象时，由于要确定每个元素的唯一性，系统就会首先自动调用对象o的int hashCode()函数。
（2），然后会把得到的o的hash code值与已经加入容器的对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果将要加入的对象o的hash code值与已经加入的容器里面的任意一个对象的hash code值不同，则将对象o加入容器。
（3），如果有对象的hash code值与o的hash code值相同，则系统会再自动调用0的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象o的hash code值相同的对象作为参数，来进行比较。
（4），如果o的boolean equals(Object obj)函数的所有返回值都是false则将对象o加入容器。
如果返回值出现true,则将对象o代替这时作为boolean equals(Object obj)的参数的对象加入容器，即用o覆盖这时的参数obj。然后终止调用o的boolean equals(Object obj)函数。
如果这些参数中，含有对象o本身，则在对象o作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止o的boolean equals(Object obj)函数的调用，然后不把对象o再次加入容器。
（5），即hS.add(Object o)，加入对象时，要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
(九)HashMap加入对象与取出对象
（1）HashMap加入对象
（1.1），HashMap的一个对象hM, 用hM.put(Object key,Object value)，加入对象时，由于要确定每个key值的唯一性，系统就会首先自动调用对象key的int hashCode()函数。
（1.2），然后会把得到的对象key的hash code值与已经加入容器的键值对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果将要加入的对象key的hash code值与已经加入的容器里面的任意一个键值对象的hash code值不同，则将对象key和value加入容器。
（1.3），如果有键值对象的hash code值与key的hash code值相同，则系统会再自动调用key的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象key的hash code值相同的键值对象作为参数，来进行比较。
（1.4），如果key的boolean equals(Object obj)函数的所有返回值都是false则将对象key和value加入容器。
如果返回值出现true,则将对象key代替这时作为boolean equals(Object obj)的参数的键值对象加入容器，即用key覆盖这时的参数obj，然后用key对应的实值value覆盖此时的obj对应的实值。最后终止调用key的boolean equals(Object obj)函数。
如果这些参数中，含有对象key本身，则在对象key作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止o的boolean equals(Object obj)函数的调用，然后键值保持不变用新实值覆盖旧覆盖。
（1.5），即hM.put(Object key,Object value)，加入对象时，要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
（2）HashMap取出对象
（2.1），HashMap的一个对象hM, hM.get(Object key)来取它对应的实值时，由于要确定容器内是否有键值和这个key对应，，系统就会首先自动调用对象key的int hashCode()函数。
（2.2），然后会把得到的对象key的hash code值与已经加入容器的键值对象的hash code值做比较（注意：比较的只是hash code值而不是对象的字符串表达式的比较，而且这一过程看不见）。如果对象key的hash code值与已经加入的容器里面的任意一个键值对象的hash code值不同，则容器内没有与key对应的键值，取出的值是null。
（2.3），如果有键值对象的hash code值与key的hash code值相同，则系统会再自动调用key的boolean equals(Object obj)函数，并且按对象加入容器的次序的相反顺序（即后加入的先作参数）逐一把所有这些与对象key的hash code值相同的键值对象作为参数，来进行比较。
（2.4），如果key的boolean equals(Object obj)函数的所有返回值都是false则容器内没有与key对应的键值，取出的值是null。。
如果返回值出现true,则取出此时作为boolean equals(Object obj)的参数的键值对象所对应的实值。然后终止调用key的boolean equals(Object obj)函数。
如果这些参数中，含有对象key本身，则在对象key作为自己的函数的参数开始调用本身的boolean equals(Object obj)函数时，系统会自动终止key的boolean equals(Object obj)函数的调用，并取出key对应的实值。
（2.5）, 要调用boolean equals(Object obj)函数的条件是： hash code值不相同和参数不能为本身。
最后：知道这些过程就能有效的定义这些函数了。哈哈！
吉林大学珠海学院2004级计算机系：才哥，E_Mail:eattea@21cn.com,QQ:398415441。联系我！！！
（学习时间有限，有错误的话请见谅！！！）88L
