标签：des blog java os io strong for ar
前面写了一篇文章是关于comparator的，那么comparable就必须拿出来做了分析对比。
关于这俩个接口的文章也比较多，本文着重从完整的代码示例去展现说明。
OK
首先，还是看下Comparator这里接口的代码：
public interface Comparable<T> {
/**
* Compares this object with the specified object for order. Returns a
* negative integer, zero, or a positive integer as this object is less
* than, equal to, or greater than the specified object.
*
* <p>The implementor must ensure <tt>sgn(x.compareTo(y)) ==
* -sgn(y.compareTo(x))</tt> for all <tt>x</tt> and <tt>y</tt>. (This
* implies that <tt>x.compareTo(y)</tt> must throw an exception iff
* <tt>y.compareTo(x)</tt> throws an exception.)
*
* <p>The implementor must also ensure that the relation is transitive:
* <tt>(x.compareTo(y)>0 && y.compareTo(z)>0)</tt> implies
* <tt>x.compareTo(z)>0</tt>.
*
* <p>Finally, the implementor must ensure that <tt>x.compareTo(y)==0</tt>
* implies that <tt>sgn(x.compareTo(z)) == sgn(y.compareTo(z))</tt>, for
* all <tt>z</tt>.
*
* <p>It is strongly recommended, but <i>not</i> strictly required that
* <tt>(x.compareTo(y)==0) == (x.equals(y))</tt>. Generally speaking, any
* class that implements the <tt>Comparable</tt> interface and violates
* this condition should clearly indicate this fact. The recommended
* language is "Note: this class has a natural ordering that is
* inconsistent with equals."
*
* <p>In the foregoing description, the notation
* <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
* <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
* <tt>0</tt>, or <tt>1</tt> according to whether the value of
* <i>expression</i> is negative, zero or positive.
*
* @param o the object to be compared.
* @return a negative integer, zero, or a positive integer as this object
* is less than, equal to, or greater than the specified object.
*
* @throws NullPointerException if the specified object is null
* @throws ClassCastException if the specified object's type prevents it
* from being compared to this object.
*/
public int compareTo(T o);
}
只有一个方法，compareTo(T o),没啥好说的，简单哈
现在，给出实现该接口的一个示例：（注意在其中的注释说明了这俩个接口的用途）
package someTest;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class ComparablePerson implements Comparable<Object> {
String firstName,lastName;
Boolean Sex;
Integer age;
public ComparablePerson(String firstName, String lastName,Boolean Sex, Integer age){
this.firstName = firstName;
this.lastName = lastName;
this.Sex = Sex;
this.age = age;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public Boolean getSex() {
return Sex;
}
public Integer getAge() {
return age;
}
//为了输入方便，重写了toString()
public String toString()
{
return firstName +" "+lastName+" "+(Sex.booleanValue()?"男":"女")+" "+age;
}
//定义比较方法
public int compare(Object o1, Object o2){
if (o1 instanceof String) {
return compareImp( (String) o1, (String) o2);
}else if (o1 instanceof Integer) {
return compareImp( (Integer) o1, (Integer) o2);
}else if (o1 instanceof Boolean) {
return compareImp( (Boolean) o1, (Boolean) o2);
}else { //根据需要扩展compare函数
System.err.println("未找到合适的比较器");
return 1;
}
}
//重载
public int compareImp(String o1, String o2) {
String s1 = (String) o1;
String s2 = (String) o2;
int len1 = s1.length();
int len2 = s2.length();
int n = Math.min(len1, len2);
char v1[] = s1.toCharArray();
char v2[] = s2.toCharArray();
int pos = 0;
while (n-- != 0) {
char c1 = v1[pos];
char c2 = v2[pos];
if (c1 != c2) {
return c1 - c2;
}
pos++;
}
return len1 - len2;
}
//重载
public int compareImp(Integer o1, Integer o2) {
int val1 = o1.intValue();
int val2 = o2.intValue();
return (val1 < val2 ? -1 : (val1 == val2 ? 0 : 1));
}
//重载
public int compareImp(Boolean o1, Boolean o2) {
return (o1.equals(o2)? 0 : (o1.booleanValue()==true?1:-1));
}
@Override
public int compareTo(Object o){
ComparablePerson p = (ComparablePerson)o;
String firstname1 = p.getFirstName();
String lastname1 = p.getLastName();
Boolean sex1 = p.getSex();
Integer age1 = p.getAge();
int compareFirstName = compare(this.firstName, firstname1);
int compareLastName = compare(this.lastName, lastname1);
int compareSex = compare(this.Sex, sex1);
if (compareFirstName != 0) {
return compareFirstName;
}
if (compareLastName != 0) {
return compareLastName;
}
if (compareSex != 0) {
return compareSex;
}
return compare(this.age, age1);
}
public static void main(String[] args) {
ComparablePerson p1 = new ComparablePerson("zangwu","gg",false,27);
ComparablePerson p2 = new ComparablePerson("zhangsan","gg",false,21);
int res = p1.compareTo(p2);
/*Returns a
* negative integer, zero, or a positive integer as this object is less
* than, equal to, or greater than the specified object.
*/
System.out.println(res);
/*
* Comparable接口和Comparator接口的不同，就是具体实现方法的不同
* 具体在实现方法中，要根据比较类的那个字段排序，由程序员自己编写
* Comparable接口的特点就是在CompareTo(Object o)方法，如果你是比较的类的编写者，就可以在要排序的类上实现
* 该接口；这就是它的特别之处；
* 在有些情况下，这个类你仅仅能调用，那么你就需要在自己的编写的类上实现Comparator接口，用 int compare(Object o1, Object o2)
* 方法来实现待比较的类实例对象的一个比较。
* 这就是很多人说的Comparable是内部的比较器，Comparator是外部的比较器。*/
ArrayList<ComparablePerson> list = new ArrayList<ComparablePerson>();
// 添加对象到ArrayList中
list.add(new ComparablePerson("ccc", "aaa",true,20));
list.add(new ComparablePerson("AAA","bbb",true,30));
list.add(new ComparablePerson("ccc", "aaa",false,10));
list.add(new ComparablePerson("ccc","aaa",false, 40));
// 打印list的原始序列
System.out.println("排序前：");
for (Iterator<ComparablePerson> iter = list.iterator(); iter.hasNext();){
ComparablePerson Person =(ComparablePerson)iter.next();
System.out.println("before sort=" +Person);
}
// 对list进行排序
// 这里会根据“ComparablePerson实现的Comparable<Object>接口”进行排序，即会根据compareTo(Object o)进行排序
Collections.sort(list);
for (int i = 0; i < list.size(); i++) {
if(i==0)
System.out.println("排序后：");
System.out.println("after sort=" + list.get(i));
}
}
}
个人意见，欢迎交流。Java comparable接口 对象排序,布布扣,bubuko.com
标签：des blog java os io strong for ar
原文地址：http://blog.csdn.net/smithdoudou88/article/details/38662939
