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]]