需求：
有一个People类，该类实例化的对象存放在对象数组中。
该类的属性有String name,int id。
请按id的大小对对象数组中的对象进行从小到大的排序。
第一种方法：用内部比较器比较
People类如下：
/*
* 为了该类的对象可以比较，实现Comparable接口，重写compareTo方法
* 这其实就定义了一个内部比较器（在要比较的对象所在类的内部）。
*/
public class People implements Comparable{
String name;
int id;
public People() {
}
public People(String name, int id) {
super();
this.name = name;
this.id = id;
}
//便于输出对象数组中对象的内容
public String toString() {
return "People:[name="+this.name+"\t id="+this.id+"]";
}
/*
* 后续在排序工具类中会用到这个方法
* 该方法中定义比较规则
*/
@Override
public int compareTo(Object o) {
People other=(People)o;
return this.id-other.id;
}
}排序工具类：
public class ArrayUtil {
public static void sort(Object[] obj) {//属性从小到大排
/*
* 无论你传什么类型的对象数组进来，只要相应类实现了
* Comparable接口，就可以将传进来的对象数组强转成
* Comparable类型的对象数组
*
*/
Comparable [] other=(Comparable[])obj;
/*
* 以下使用的是冒泡排序，冒泡排序和快速排序别搞混
*/
for(int i=0;i<obj.length;i++) {
for(int j=0;j<obj.length-i-1;j++) {
/*
* 调用了People类的compareTo方法
* 该类实现了Comparable接口，重写了compareTo()方法
* 这儿运用了多态哦
*/
if(other[j].compareTo(other[j+1])>0) {
Comparable temp;
temp=other[j];
other[j]=other[j+1];
other[j+1]=temp;
}
}
}
}
}测试类：
import java.util.Arrays;
public class ArrayTest {
static People []pe=new People[5]; //定义长度为5的People对象数组
public static void main(String[] args) {
/*
* 通过循环给对象数组传值
*
*/
for(int i=0;i<pe.length;i++) {
pe[i]=new People((i+1)+"nana",(i+1));//任何类型和字符串拼接都会变成字符串
}
//调用排序工具类的排序方法，将一个对象数组传入
ArrayUtil.sort(pe);
//将对象数组中的元素转成字符串并输出
System.out.println(Arrays.toString(pe));
}
}输出结果：
[People:[name=1nana id=1], People:[name=2nana id=2], People:[name=3nana id=3], People:[name=4nana id=4], People:[name=5nana id=5]]
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
第二种方法：利用外部比较器比较
注意：既然是外部比较器，那比较器就是定义在People类外部，故People类不需要因为比较器的原因添加任何代码
People类：
public class People{
String name;
int id;
public People() {
}
public People(String name, int id) {
super();
this.name = name;
this.id = id;
}
//便于输出对象数组中对象的内容
public String toString() {
return "People:[name="+this.name+"\t id="+this.id+"]";
}
}
比较器类：
import java.util.Comparator;
/*
* 定义的比较器类需要实现Comparator接口，重写compare方法
*
* 记忆诀窍：
* 内部比较器 Comparable接口 compareTo(Object o) 定义在要比较的对象所属类的内部
* 外部比较器 Comparator接口 compare(Object o1,Object o2) 写一个比较器类
*/
public class bijiaoqi implements Comparator {
/*
* 重写Comparator接口的compare方法
* 定义比较规则
*/
@Override
public int compare(Object o1, Object o2) {
People pe1=(People)o1;
People pe2=(People)o2;
return pe1.id-pe2.id;
}
}
排序工具类：
import java.util.Comparator;
public class ArrayUtil {
/*
* 方法接收一个对象数组和一个比较器
*/
public static void sort(Object[] obj,Comparator com) {
/*
* 以下使用的是冒泡排序的算法
*/
for(int i=0;i<obj.length;i++) {
for(int j=0;j<obj.length-i-1;j++) {
/*
*此处调用了比较器重写的compare方法
*/
if(com.compare(obj[j],obj[j+1])>0) {
Object temp;
temp=obj[j];
obj[j]=obj[j+1];
obj[j+1]=temp;
}
}
}
}
}测试类：
import java.util.Arrays;
public class ArrayTest {
static People []pe=new People[5]; //定义长度为5的People对象数组
public static void main(String[] args) {
/*
* 通过循环给对象数组传值
*
*/
for(int i=0;i<pe.length;i++) {
pe[i]=new People((i+1)+"nana",(i+1));//
}
//调用排序工具类的排序方法，将一个对象数组和比较器传入排序工具类的sort方法
ArrayUtil.sort(pe,new bijiaoqi());
//将对象数组中的元素转成字符串并输出
System.out.println(Arrays.toString(pe));
}
}执行结果：
[People:[name=1nana id=1], People:[name=2nana id=2], People:[name=3nana id=3], People:[name=4nana id=4], People:[name=5nana id=5]]
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
第三种方式：利用外部比较器加匿名内部类实现
解析：由于比较器类只用一次，故我们可以在测试类中创建一个比较器的匿名内部类，以下这种方法的代码People类、排序工具类完全一致
People类：
public class People{
String name;
int id;
public People() {
}
public People(String name, int id) {
super();
this.name = name;
this.id = id;
}
//便于输出对象数组中对象的内容
public String toString() {
return "People:[name="+this.name+"\t id="+this.id+"]";
}
}
排序工具类：
import java.util.Comparator;
public class ArrayUtil {
/*
* 方法接收一个对象数组和一个比较器
*/
public static void sort(Object[] obj,Comparator com) {
/*
* 以下使用的是冒泡排序的算法
*/
for(int i=0;i<obj.length;i++) {
for(int j=0;j<obj.length-i-1;j++) {
/*
*此处调用了比较器重写的compare方法
*/
if(com.compare(obj[j],obj[j+1])>0) {
Object temp;
temp=obj[j];
obj[j]=obj[j+1];
obj[j+1]=temp;
}
}
}
}
}测试类：
import java.util.Arrays;
import java.util.Comparator;
public class ArrayTest {
static People []pe=new People[5]; //定义长度为5的People对象数组
public static void main(String[] args) {
/*
* 通过循环给对象数组传值
*
*/
for(int i=0;i<pe.length;i++) {
pe[i]=new People((i+1)+"nana",(i+1));//
}
//调用排序工具类的排序方法，将一个对象数组和比较器传入排序工具类的sort方法
//使用Comparator接口实例化一个匿名内部类
ArrayUtil.sort(pe,new Comparator() {
@Override
public int compare(Object o1, Object o2) {
People pe1=(People)o1;
People pe2=(People)o2;
return pe1.id-pe2.id;//比较规则
}
});
//将对象数组中的元素转成字符串并输出
System.out.println(Arrays.toString(pe));
}
}
运行效果：
[People:[name=1nana id=1], People:[name=2nana id=2], People:[name=3nana id=3], People:[name=4nana id=4], People:[name=5nana id=5]]