JAVA中Arrays.sort()使用两种方式（Comparable和Comparator接口）对对象或者引用进行排序

最新推荐文章于 2023-09-25 22:13:44 发布
最新推荐文章于 2023-09-25 22:13:44 发布
阅读量4k 收藏 17
点赞数 6
分类专栏： java 文章标签： Array.sort
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenjiusui8083/article/details/78236108
版权

JAVA中Arrays.sort()使用两种方式（Comparable和Comparator接口）对对象或者引用进行排

这里我们采用两种方式，一种是使用Comparable接口：让待排序对象所在的类实现Comparable接口，并重写Comparable接口中 compareTo()方法，缺点是只能按照一种规则排序。

另一种方式是使用Comparator接口：编写多个排序方式类实现Comparator接口，并重写新Comparator接口中的compare()方法，在调用Arrays的sort()时将排序类对象作为参数传入：public static void sort(T[] a,Comparatorc),根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的(也就是说，对于数组中的任何 e1 和 e2 元素而言，c.compare(e1, e2) 不得抛出 ClassCastException)。

优点是可以按照多种方式排序，你要按照什么方式排序，就创建一个实现Comparator接口的排序方式类，然后将该排序类的对象传入到Arrays.sort(待排序对象，该排序方式类的对象)

数组的length是一个属性，而字符串的length()是一个方法了！！！虽然都是求的他们各自的长度( 与此题无关 )。

Sorting an Array ：

      1. 数字排序  int[] intArray = new int[] { 4, 1, 3, -23 };

　　Arrays.sort(intArray);

　　输出： [-23, 1, 3, 4]

　　2. 字符串排序，先大写后小写 String[] strArray = new String[] { "z", "a", "C" };

　　Arrays.sort(strArray);

　　输出： [C, a, z]

　　3. 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort

　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

　　输出： [a, C, z]

　　4. 反向排序， Reverse-order sort

　　Arrays.sort(strArray, Collections.reverseOrder());

　　输出：[z, a, C]

　　5. 忽略大小写反向排序 Case-insensitive reverse-order sort

　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

　　Collections.reverse(Arrays.asList(strArray));

　　输出： [z, C, a]

　　java初学者最常见的错误思想，就是试图去写一些方法来完成数组的排序功能，其实，数组排序功能，在java的api里面早已实现，我们没有 必要去重复制造轮子。


二、源代码 (两种方式（Comparable和Comparator接口）对对象或者引用进行排序)

方式1：使用Comparable接口

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package tong.day4_27.systemUse;
 
import java.util.Arrays;
/**
  * 使用Comparable接口：让待排序对象所在的类实现Comparable接口，并重写Comparable接口中的compareTo()方法
  * 缺点是只能按照一种规则排序
  * @author tong
  *
  */
public class ObjectSort {
 
     public static void main(String[] args) {
         Person[] persons = new Person[ 5 ];
         persons[ 0 ] = new Person( "tom" , 45 );
         persons[ 1 ] = new Person( "jack" , 12 );
         persons[ 2 ] = new Person( "bill" , 21 );
         persons[ 3 ] = new Person( "kandy" , 34 );
         persons[ 4 ] = new Person();
         Arrays.sort(persons);
         for (Person person:persons) {
             System.out.println(person);
         }
 
     }
 
}
class Person implements Comparable<person>{
     private String name;
     private int age;
     
     public Person(String name, int age){
         this .name = name;
         this .age = age;
     }
     public Person(){
         this ( "unknown" , 0 );
     }
     //重写该类的compareTo()方法，使其按照从小到大顺序排序
     @Override
     public int compareTo(Person o) {
          return age-o.age;
         
     }
     //重写Student类的toString()方法，在输入对象时按照以下方式输出
     @Override
     public String toString() {     
         return "Person[name:" +name+ ",age:" +age+ "]" ;
     }
     
}</person>
运行结果：

 

comparable

 

方式2：使用Comparator接口

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package tong.day4_27.systemUse;
 
import java.util.Arrays;
import java.util.Comparator;
 
/**
  * 使用Comparator接口：编写多个排序方式类实现Comparator接口，并重写新Comparator接口中的compare()方法
  * public static <t> void sort(T[] a,Comparator<!--? super T--> c),根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的
  * （也就是说，对于数组中的任何 e1 和 e2 元素而言，c.compare(e1, e2) 不得抛出 ClassCastException）。
  * 优点是可以按照多种方式排序，你要按照什么方式排序，就创建一个实现Comparator接口的排序方式类，然后将该排序类的对象传入到Arrays.sort(待排序对象，该排序方式类的对象)
  * @author tong
  *
  */
 
public class ComparatorUse {
 
     
     public static void main(String[] args) {
         Student[] persons = new Student[ 5 ];
         persons[ 0 ] = new Student( "tom" , 1 , 88 , 45 );
         persons[ 1 ] = new Student( "jack" , 6 , 80 , 12 );
         persons[ 2 ] = new Student( "bill" , 4 , 68 , 21 );
         persons[ 3 ] = new Student( "kandy" , 2 , 98 , 34 );
         persons[ 4 ] = new Student( "lily" , 5 , 94 , 20 );
         System.out.println( "排序前的数据：" );
         for (Student student:persons) {
             System.out.println(student);
         }
         //创建SortByNumber对象，将其作为参数传入Arrays.sort(persons,sortByNumber)方法中
         SortByNumber sortByNumber = new SortByNumber();
         Arrays.sort(persons,sortByNumber);
         System.out.println( "根据学生编号由低到高排序：" );
         for (Student student:persons) {
             System.out.println(student);
         }
         SortByScore sortByScore = new SortByScore();
         Arrays.sort(persons,sortByScore);
         System.out.println( "根据学生成绩由高到低排序：" );
         for (Student student:persons) {
             System.out.println(student);
         }
 
 
     }
 
}
 
class Student {
     private String name;
     private int number;
     private int score;
     private int age;
     
     public Student(String name, int number, int score, int age){
         this .name = name;
         this .number = number;
         this .score = score;
         this .age = age;
     }
     //重写Student类的toString()方法，在输入对象时按照以下方式输出
     @Override
     public String toString() {     
         return "Student[name:" +name+ ",age:" +age+ ",number:" +number+ ",score:" +score+ "]" ;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this .name = name;
     }
 
     public int getNumber() {
         return number;
     }
 
     public void setNumber( int number) {
         this .number = number;
     }
 
     public int getScore() {
         return score;
     }
 
     public void setScore( int score) {
         this .score = score;
     }
 
     public int getAge() {
         return age;
     }
 
     public void setAge( int age) {
         this .age = age;
     }
     
     
     
}
//按照学号由低到高排列,创建SortByNumber类，该类实现Comparator，重写该接口的compare()
class SortByNumber implements Comparator<student>{
     //重写该接口的compare()使其按照学号由小到大排序（前者减去后者）
     @Override
     public int compare(Student o1, Student o2) {
         return o1.getNumber()-o2.getNumber();
         
     }
     
}
//按照分数由高到低排列，创建SortByScore类，该类实现Comparator，重写该接口的compare()
class SortByScore implements Comparator<student>{
     //重写该接口的compare()使其按照分数由高到低排序（后者减去前者）
     @Override
     public int compare(Student o1, Student o2) {
         return o2.getScore()-o1.getScore();
         
     }
     
}</student></student></t>
运行结果：

 

加载中...vcg==" src="http://img.2cto.com/Collfiles/20150428/20150428084639195.png" />


夏天的风欧阳冰嫣
关注
  • 6
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java Arrays.sort和Collections.sort排序实现原理解析
08-25
主要介绍了Java Arrays.sort和Collections.sort排序实现原理解析，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
深入理解Arrays.sort(）
热门推荐
github_38838414的博客
06-10 6万+
深入理解Java 中的Arrays.sort(）方法 Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，非常的好用。 但是sort()的参数有好几种，基本上是大同小异，下面是以int型数组为例的Arrays.sort(）的典型用法 import java.util.Arrays; import java.util.Comparato...
Java数组排序Arrays.sort，以及Comparator接口的用法
giianhui的专栏
06-06 3万+
有的时候需要对数组里的element进行排序。当然可以自己编写合适的排序方法，但既然java包里有自带的Arrays.sort排序方法，在 数组元素比较少的时候为何不用？ 　　Sorting an Array 1. 数字排序  int[] intArray = new int[] { 4, 1, 3, -23 };　　Arrays.sort(intArray);　　输出： [-23, 1, 3, 4]　　2. 字符串排序，先大写后小写 String[] strArray = new String[]
java中的Arrays.sort()的几种用法
码农研究僧的博客
05-13 4万+
直奔主题 Arrays.sort()有三种用法 第一种是Arrays.sort(int [] a) 查看源码 public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0); } 即对一个数组的所有元素进行排序 而且排序的时候是从小到大 所以在使用的时候则为 public class text1 { public static void main(Stri
Arrays中sort方法升序,降序,和引用数组类型的排序, binarySearch等方法的分析
m0_73955675的博客
09-25 343
o1-->表示在无序序列中,遍历得到的每一个元素 o2-->有序序列中的元素 如果 o1 大于 o2 ，比较器返回1。这意味着在排序后的数组中,o1 应该位于 o2 之后。 如果 o1 小于 o2 ，比较器返回-1。这意味着在排序后的数组中, o1 应该位于 o2 之前 如果 o1 等于 o2， 比较器返0。 这意味着 o1 和 o2 的顺序并不重要，它们可以以任何顺序出现 分析(o1-o2): 返回值为正数 : 表示当前要插入的元素是大的,放在后面
还不快收藏?Arrays.sort()非常常用的几个方法
weixin_44717588的博客
03-18 2748
Arrays类位于java.util 包中: Arrays包含用于操作数组的各种方法,比如二分查找等等,但是今天介绍其中的sort方法,sort()方法用于对数组进行排序,但排序的情况有所不同: 1.Arrays.sort(int[] a) 上面是对int类型的数组a进行升序排序,比如一个数组送的元素是:[8,3,6,9,1,7],用上面的方法进行排序的结果是:[1,3,6,7,8,9].数组的类型可以是8种基本类型中的任意类型. 2.Arrays.sort(Object[] a) 这个方..
Arrays类的sort()方法实现Comparable接口对象数组排序
m0_37732829的博客
08-22 1792
     Arrays类中的sort方法承诺可以对对象数组进行排序，但要求满足下列前提：对象所属的类必须实现了Comparable接口。下面是Comparable接口的代码： //Java SE 5.0之前： public interface Comaprable { public int comparableTo(Object other); } //Java SE 5.0中，Compar...
PTA练习02编程题
drizzle2333的博客
11-28 3680
jmu-Java-03面向对象基础-04-形状-继承 jmu-Java-03面向对象基础-05-覆盖 jmu-Java-04面向对象进阶--02-接口-Comparator jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack 横平竖直 集体评分 集体评分2 程序改错题2 程序填空题3
PTA 集合排序（Java）
Anemia_的博客
06-28 1660
文章目录1.多数组排序 (15 分)2.jmu-Java-04面向对象进阶--02-接口-Comparator (15 分)3.职工排序题 (20 分)4.利用集合类排序 (15 分)5.jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company (15 分)6.sdust-Java-学生成绩读取与排序 (20 分) 1.多数组排序 (15 分) 3个整数数组进行整体排序，根据输入的三个数组的元素，输出排序后的结果（从大到小） 输入格式: 第1个数
5.2 jmu-Java-04面向对象进阶--02-接口-Comparator (5 分)
wzy992981933的博客
04-22 814
Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 1.编写PersonSortable2类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toString方法：返回格式name-age 2 编写Comparator类 编写
7-4 jmu-Java-04面向对象进阶--02-接口-Comparator （20 分）
markconca的博客
01-02 4242
7-4 jmu-Java-04面向对象进阶--02-接口-Comparator （20 分） Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 1.编写PersonSortable2类 ...
JAVA基于Arrays.sort()实现数组升序和降序
08-19
主要介绍了JAVA基于Arrays.sort()实现数组升序和降序,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
探究Comparable接口中CompareTo的方法，即其中的Arrays.sort排序底层原理（利接口回调来对学生数组中的对象信息排序）
12-22
大家好，我是Ziph！...好多同学或者读者认为感觉自己学到这里，不知道该从何写起，而我在探究Comparable接口底层原理的同时，写了详细的步骤1、2、3、4、5、6、7、8（一共8个步骤，按数字找有相应书写和想法
java中的arrays.sort()代码详解
08-28
主要介绍了Java中的Arrays.sort()代码详解，涉及Arrays.sort()简单示例，策略模式，”super”的使用等相关内容，具有一定借鉴价值，需要的朋友可以参考下。
深入理解java中Arrays.sort()的用法
08-19
主要介绍了深入理解java中Arrays.sort()的用法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
这是一个基于Objective-C语言的基础案例集。旨在用于给初学者快速了解Objective-C语言的语法。.zip
04-30
这是一个基于Objective-C语言的基础案例集。旨在用于给初学者快速了解Objective-C语言的语法。.zip
01 整理数据 _ 合并多数据，分析更有趣.ipynb
04-30
01 整理数据 _ 合并多数据，分析更有趣.ipynb
jsp140汽车测评推荐新闻管理系统ssh+mysql.zip
04-30
创业、工作、毕业、课程需要人群，可以参考使用，支持有偿远程部署，联系我，保证一定能跑起来
流程行业智能工厂总体设计方案qy.pptx
最新发布
04-30
流程行业智能工厂总体设计方案qy.pptx
写一个comparable接口 和comparator的例子 要求用arrays.sort进行对象排序
04-07
要写一个comparable接口和comparator的例子，要求用arrays.sort进行对象排序。 comparable接口是用于实现对象自身可以进行排序的接口，需要实现compareTo方法，而comparator则是通过外部比较器进行排序的接口，需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值