Java复习笔记——Comparable 和 Comparator接口 引用类型比较

Comparable 接口

“排序”的实体类必须实现Comparable接口，Comparable接口中只有一个方法comparableTo（Object obj）

返回值:

- 0 表示两个对象相等

- 正数 this>obj

- 负数 this

int 类型比较（Integer）

return (i>o)?(i-o):((i==o)?0:(i-o));

char类型比较（Charactor）

return c1-c2 ；

字符串比较

public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;

int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}

首先获取两个字符串的长度，并获取长度短的String长度，遍历两个字符串，如果对应位置的字符不同，则返回两字符的差，如果两个字符串每个字符都相同，则返回两个字符串长度差

Comparable 案例

我们根据 猫的年龄给猫进行排序，猫就是我们的带排序实体类，所以需要实现Comparable接口

public class Cat implements Comparable<Cat> {
public String name;
public int age;

public Cat(String name, int age) {
super();
this.name = name;
this.age = age;
}

public Cat() {
super();
// TODO Auto-generated constructor stub
}

@Override
public int compareTo(Cat o) {
// TODO Auto-generated method stub
return this.age > o.age ? 1 : (this.age == o.age ? 0 : -1);
}

@Override
public String toString() {
return "Cat [name=" + name + ", age=" + age + "]";
}

}

接下来我们创建测试类，进行测试

public class ComparaTest {

public static void main(String[] args) {

Cat[] cats = new Cat[] { new Cat("Tom", 2), new Cat("Jack", 5),
new Cat("Tony", 3), };
Arrays.sort(cats);
System.out.println(Arrays.toString(cats));
}

}

打印结果：

[Cat [name=Tom, age=2], Cat [name=Tony, age=3], Cat [name=Jack, age=5]]

如果我们想Cat按name排序，只需要在 compareTo(Cat o)方法中将排序规则改成上面的String 排序即可；

Comparator 接口

Comparator接口就比较强大了，我们每天逛淘宝、京东里面浏览商品的时候，可以选择，根据价格、销量、综合等排序，那我们怎么实现这样的功能呢？我们不可能使用Comparable接口来实现，因为我们很难在compareTo（）方法内动态选择，但是我们使用Comparator接口的化就可以轻松实现。因为Comparator接口实现了代码分离，我们的比较逻辑不用写在待排序实体类内，下面是Comparator接口的例子

创建Dog，Dog是我们的待排序实体类，但这里知识简单的Dog，不用实现任何接口

public class Dog {
public String name;
public int age;

public Dog(String name, int age) {
super();
this.name = name;
this.age = age;
}

public Dog() {
super();
// TODO Auto-generated constructor stub
}

@Override
public String toString() {
return "Dog [name=" + name + ", age=" + age + "]";
}
}

这里实现代码分离，单独写Comparator接口，这里我们依然以年龄来比较

public class DogComparatorByAge implements Comparator<Dog> {

@Override
public int compare(Dog o1, Dog o2) {

return o1.age > o2.age ? 1 : (o1.age == o2.age ? 0 : -1);
}

}

下面是我们的测试逻辑

public class ComparaTest {

public static void main(String[] args) {

Dog[] dogs = new Dog[] { new Dog("Tom", 2), new Dog("Jack", 5),
new Dog("Tony", 3), };

Arrays.sort(dogs, new DogComparatorByAge());

System.out.println(Arrays.toString(dogs));
}

测试结果：

[Dog [name=Tom, age=2], Dog [name=Tony, age=3], Dog [name=Jack, age=5]]

重点来了，我们如何进行动态改变排序规则，这里我们添加一个按name排序的规则

public class DogComparatorByName implements Comparator<Dog> {

@Override
public int compare(Dog o1, Dog o2) {

int len1 = o1.name.toCharArray().length;
int len2 = o2.name.toCharArray().length;
int lim = Math.min(len1, len2);
char v1[] = o1.name.toCharArray();
char v2[] = o2.name.toCharArray();

int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}

}

我们的两个排序规则已经写好了，下面就是进行动态改变了。

public class ComparaTest {

public static void main(String[] args) {

Dog[] dogs = new Dog[] { new Dog("Tom", 2), new Dog("Jack", 5),
new Dog("Tony", 3), };

Arrays.sort(dogs, new DogComparatorByAge());

System.out.println("通过Age排序"+Arrays.toString(dogs));

Arrays.sort(dogs, new DogComparatorByName());

System.out.println("通过Nme排序"+Arrays.toString(dogs));
}

}

测试结果：

通过Age排序[Dog [name=Tom, age=2], Dog [name=Tony, age=3], Dog [name=Jack, age=5]]

通过Nme排序[Dog [name=Jack, age=5], Dog [name=Tom, age=2], Dog [name=Tony, age=3]]