一.比较器Comparable和Comparator

上一篇博客介绍了工具类Arrays工具类 。我们可以对基本类型的数组调用Arrays.sort()函数来进行数组的排序。排序操作在日常开发中经常要使用到。那么String类和自定义类能不能使用Arrays.sort()来进行排序呢。下面我们来试试，如下：

Java代码

publicclassMystring {

2. publicstaticvoidmain(String[] args) {

4. String []a={"早上","中午","下午","傍晚","晚上"};

6. Person[] b={ newPerson("小白",15),newPerson("小黑",19),

7. newPerson("小红",14),newPerson("小紫",20)};

8. Arrays.sort(a);

9. for(inti=0;i<a.length;i++)

10. System.out.print(a[i]);

11. System.out.print("\r\n");

13. Arrays.sort(b);

14. for(inti=0;i<b.length;i++)

15. System.out.println(b[i]);

16. }

18. }

19. //自定义类

20. classPerson {

22. publicString name;

24. publicintage;

26. publicPerson(String name,intage) {

27. this.name=name;

28. this.age=age;

30. }

32. }

程序运行结果：

我们发现String可以调用Arrays.sort()函数，而我们自定义的Person类报错，看错误的关键字Comparable

打开String源码

由此引入比较器Comparable，我们下面利用Comparable接口来实现Person使用Arrays.sort()按年龄排序递增排序。

Comparable接口能够对实现它的类的对象进行排序，主要使用compareTo函数来实现排序。compareTo函数返回int类型，分别返回-1,0,1对应小于，等于，大于。

把代码改为：

Java代码

1. publicclassMystring {

3. publicstaticvoidmain(String[] args) {

5. String []a={"早上","中午","下午","傍晚","晚上"};

7. Person[] b={ newPerson("小白",15),newPerson("小黑",19),

8. newPerson("小红",14),newPerson("小紫",20)};

9. Arrays.sort(a);

10. for(inti=0;i<a.length;i++)

11. System.out.print(a[i]);

12. System.out.print("\r\n");

14. Arrays.sort(b);

15. for(inti=0;i<b.length;i++)

16. System.out.println(b[i]);

17. }

19. }

20. //自定义类

21. classPerson implementsComparable<Person>{

23. publicString name;

25. publicintage;

27. publicPerson(String name,intage) {

28. this.name=name;

29. this.age=age;

31. }

32. //比较器的比较函数

33. /**

34. * 如果当前对象小于比较对象，返回-1

35. * 如果当前对象等于比较对象，返回0

36. * 如果当前对象大于比较对象，返回1

37. */

38. @Override

39. publicintcompareTo(Person o) {

40. //对象为空，抛出空指针异常

41. if(o==null)

42. thrownewNullPointerException();

43. if(this.age<o.age)

44. return-1;

45. if(this.age>o.age)

46. return1;

47. return0;

48. }

49. //重写toString方法

50. @Override

51. publicString toString() {

52. return"Person [name="+ name + ", age="+ age + "]";

53. }

55. }

运行结果：

为自定义的Person实现比较器Comparable接口，即可调用Arrays.sort（）进行排序。

另外还有另一种实现方法，实现Comparator接口。

Java代码

1. publicclassMystring {

3. publicstaticvoidmain(String[] args) {

5. String []a={"早上","中午","下午","傍晚","晚上"};

7. Person[] b={ newPerson("小白",15),newPerson("小黑",19),

8. newPerson("小红",14),newPerson("小紫",20)};

9. Arrays.sort(a);

10. for(inti=0;i<a.length;i++)

11. System.out.print(a[i]);

12. System.out.print("\r\n");

14. Arrays.sort(b,newPersonComparator());

15. for(inti=0;i<b.length;i++)

16. System.out.println(b[i]);

17. }

19. }

20. //自定义类

21. classPerson {

22. publicString name;

24. publicintage;

26. publicPerson(String name,intage) {

27. this.name=name;

28. this.age=age;

30. }

31. @Override

32. publicString toString() {

33. return"Person [name="+ name + ", age="+ age + "]";

34. }

36. }

38. classPersonComparator implementsComparator<Person>{

40. //比较器的比较函数

41. /**

42. * 如果当前对象小于比较对象，返回-1

43. * 如果当前对象等于比较对象，返回0

44. * 如果当前对象大于比较对象，返回1

45. */

46. @Override

47. publicintcompare(Person o1, Person o2) {

48. //对象为空，抛出空指针异常

49. if(o1==null||o2==null)

50. thrownewNullPointerException();

51. if(o1.age<o2.age)

52. return-1;

53. if(o1.age>o2.age)

54. return1;

55. return0;

56. }

58. }

二.对象的克隆Clone

将一个对象复制一份，称作对象的克隆技术。克隆对象分为两步。

1.实现Cloneable标记接口

Cloneable是一个标记接口，此接口没有定义任何方法。只是作为一个标记给虚拟机。

2.重写Object的clone方法

Java代码

1. //自定义类person实现Cloneable接口

2. classPerson implementsCloneable {

3. publicString name;

5. publicintage;

7. publicPerson(String name,intage) {

8. this.name=name;

9. this.age=age;

11. }

12. //重写Object的clone方法

13. @Override

14. protectedObject clone() throwsCloneNotSupportedException

15. {

16. returnsuper.clone();

17. }

19. }

克隆的调用：

Java代码

1. publicstaticvoidmain(String[] args) {

3. Person temp=newPerson("王尼玛",18);

5. try{

6. Person ok=(Person)temp.clone();//把Object类转化为Person、

7. System.out.println(ok.name);//输出王尼玛

8. } catch(CloneNotSupportedException e) {

9. e.printStackTrace();

10. }

12. }

这样既可以完成对一个对象的克隆，当我们要创建一系列类似的对象时，可以考虑使用克隆技术可以得到更好的性能，比你new创建好一些。

java对象比较器和克隆