Java集合排序方法comparable和comparator的总结

曾经终败给现在 2022-05-21 10:19 260阅读 0赞

Java集合排序方法的总结

\-\----接口comparable和接口comparator的比较

一.相关概念

Comparable和Comparator都是用来实现集合中元素的比较、排序的。  
   （一） Comparable

Comparable是在集合内部定义的方法实现的排序，位于java.util下。是一个对象本身就已经支持自比较所需要实现的接口，如String、Integer自己就实现了Comparable接口，可完成比较大小操作。自定义类要在加入list容器中后能够排序，也可以实现Comparable接口，在用Collections类的sort方法排序时若不指定Comparator，那就以自然顺序排序。所谓自然顺序就是实现Comparable接口设定的排序方式。  
  
  （二）Comparator

Comparator是在集合外部实现的排序，位于java.lang下。是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足要求时，可写一个比较器来完成两个对象之间大小的比较。Comparator体现了一种策略模式(strategy design pattern)，就是不改变对象自身，而用一个策略对象(strategy object)来改变它的行为。使用方法只能用Collections类的sort方法，并且是传递两个参数进去（List list，Class class），第一个参数是集合的对象list，第二个是实现了comparator接口的实现类的对象。

总而言之Comparable是自已完成比较，Comparator是外部程序实现比较。

二．详细示例

（一）comparable详细使用方法

1. 功能：按照存储的对象的某个属性排列来显示该对象的所有属性

2. 使用方法：

使用要注意下，存放TreeSet类的的元素，必须要对泛型实现Comparable接口， 否则运行时add方法就报错，重写compareTo方法就可以排序，而HashSet不支持排序。

如果要对List的实现类ArrayList和LinkedList里面的对象的元素进行排序就要使用Collections的方法sort（List list），把list的值放进去就可以了

（1）Comparable是一个接口，需要实现后才能使用， 比如：要对User这个对象的某个属性来排列显示时，Comparable被实现时需要在后面添加泛型如：类名 implements Comparable<User>

（2）实现接口后要重写方法compareTo（只有一个参数），

（3）如果比较的的数字，方法返回number-Object.number

（4）如果比较的的字符串，方法返回string.equal(Object.string)

（5）正常是按升序排列，在返回前面加个负号就可以降序排列

3.Comparable的示例

（1）泛型类实现Comparable

1.  package com.xykj.comparable;
2.  public classUserimplementsComparable\{ *//这里的User是后面集合类的泛型*
3.  String name = "";
4.  String password = "";
5.  publicUser(String name, String password)\{
6.  this.name = name;
7.  this.password = password;
8.  \}
9.  *// 实现排序必须要重写的方法*
10. @Override
11. publicintcompareTo(User o)\{ *//按照密码的升序排列，想要按照名字排序就把password换成name就可以了*
12. return password.compareTo(o.password);
13. \}
14. *// 重写toString方法*
15. @Override
16. public String toString()\{
17. return name + " " \+ password;
18. \}
19. \}

（2）TreeSet类的排序

1.  package com.xykj.comparable;
2.  import java.util.TreeSet;
3.  public classStreeSetTest\{
4.  *// TreeSet类的使用，可以对存放的数据进行排序*
5.  publicstaticvoidmain(String\[\] args)\{
6.  *//TreeSet能够排序是因为泛型User类，已经实现了Comparable接口*
7.  TreeSet tSet = new TreeSet<>();
8.  for ( int i = 1; i <= 10; i++) \{
9.  *//如果泛型User类没有实现Comparable接口，add方法就报错*
10. tSet.add( new User( "TreeSet" \+ i, "TreeSet" \+ ( 50 \- i)));
11. \}
12. *//Collections.sort(tSet);不能使用，sort里面只能存放List类的对象*
13. for (User user : tSet) \{
14. System.out.println(user.toString()); *//因为重写了toString方法，所以会显示User的名字和密码*
15. \}
16. \}
17. \}

运行结果：

![20160910130143170][]

虽然是按照name的升序添加的，但是结果还是按照password的升序排列

（3）HashSet的演示

1.  package com.xykj.comparable;
2.  import java.util.HashSet;
3.  public classHashSetTest\{
4.  *// HashSet类的使用，不支持对元素数据进行排序*
5.  publicstaticvoidmain(String\[\] args)\{
6.  *//即使泛型User类实现了comparable接口，但是结果还是没有排序*
7.  HashSet hSet = new HashSet<>();
8.  for ( int i = 1; i <= 10; i++) \{
9.  *//即使泛型User类没有实现了comparable接口，add方法也不会报错*
10. hSet.add( new User( "hSet\_name" \+ i, "hSet\_password" \+ ( 50 \- i)));
11. \}
12. for (User user : hSet) \{
13. System.out.println(user.toString());
14. \}
15. \}
16. \}

运行结果：

![20160910130720787][]

同样是按照升序进行添加的，但是无论name还是password都没有一点顺序

（4）ArrayList的排序，重点理解哦

1.  package com.xykj.comparable;
2.  import java.util.ArrayList;
3.  import java.util.Collections;
4.  public classArrayListTest \{ 
5.  *//对ArrayList排序必须要使用Collections.sort(list)，否则不会排序，*
6.  *//会按照添加的顺序打印出来*
7.  publicstaticvoidmain(String\[\] args)\{
8.  ArrayList list = new ArrayList<>();
9.  for ( int i = 1; i <= 10; i++) \{
10. list.add( new User( "ArrayList\_name" \+ i, " ArrayList\_password" \+ ( 50 \- i)));
11. \}
12. *//Collections.sort(list);先注释看看结果*
13. for (User user : list) \{
14. System.out.println(user.toString());
15. \}
16. \}
17. \}

运行结果：

![20160910130916243][]

没有使用Collections.sort(list);的情况下怎样的顺序添加的就按照怎样的顺序输出

如果使用Collections.sort(list);把注释的代码放出来，还是上面的代码：

![20160910131046252][]

运行的结果就会发生变化：

![20160910131136908][]

按照密码的升序排列出来，而不是输入的顺序。

（5）LInkedList的排序

1.  package com.xykj.comparable;
2.  import java.util.Collections;
3.  import java.util.LinkedList;
4.  public classLinkedListTest \{ 
5.  *//LinkedList的排序*
6.  publicstaticvoidmain(String\[\] args)\{
7.  LinkedList list = new LinkedList<>();
8.  for ( int i = 1; i <= 10; i++) \{
9.  list.add( new User( "LinkedList\_name" \+ i, "LinkedList\_password" \+ ( 50 \- i)));
10. \}
11. *//使用sort方法排序*
12. Collections.sort( list);
13. for (User user : list) \{
14. System.out.println(user.toString());
15. \}
16. \}
17. \}

运行结果：

![20160910131419597][]

效果和ArrayList是一样的，如果没有使用sort方法也是会按照添加顺序打印出来

Comparable的总结，使用Comparable可以对TreeSet类的元素进行排序，也可以对ArrayList类和LinkedList类的元素进行排序。

对TreeSet类排序的理解，这个和TreeSet的存储方式有关，不排序就不让你存储的意思。

对ArrayList类和LinkedList类排序的理解，这个其实和Arrays类相似，Arrays类有sort方法可以直接传入一个数组名字，

该数组就会被从小到大排序，其实是差不多的意思。这里的Collections类也有一个sort方法，但是只能传递List类型的对象。

（一）Comparator详细使用方法

1. 功能：按照存储的对象的某个属性排列来显示该对象的所有属性，只能对任意集合List接口下的实现类ArrayList和LinkedList进行排序

2.使用方法：

（1）需要在另一个类是实现Comparator，同样后面也要加泛型，这个泛型是需要排序的自定义类

（2）要重写compare方法，比较Object里面的具体属性用compareTo

（3）需要Collections工具类的sort方法，方法里面传入两个参数：第一个参数是列表信息list，第二个参数是实现了comparator的类的对象

3.Comparator的示例

（1）先建一个基本属性类

1.  package com.xykj.comparatorTest;
2.  public classStudent\{
3.  *//创建两个基本属性*
4.  String name= "";
5.  int age= 0;
6.  
7.  *//从写构造方法用来传递数据*
8.  publicStudent(String name, int age)\{
9.  super();
10. this.name = name;
11. this.age = age;
12. \}
13. *//从写toString方法，方便显示*
14. @Override
15. public String toString()\{
16. return name + " " \+ age ;
17. \}
18. 
19. *//基本属性的get和set方法*
20. public String getName()\{
21. return name;
22. \}
23. publicvoidsetName(String name)\{
24. this.name = name;
25. \}
26. publicintgetAge()\{
27. return age;
28. \}
29. publicvoidsetAge(int age)\{
30. this.age = age;
31. \}
32. 
33. \}

（2）创建按照姓名升序排列的实现类

1.  package com.xykj.comparatorTest;
2.  
3.  import java.util.Comparator;
4.  *//按照名字的升序排列 实现接口 泛型是自定义类，里面有要排序的内容* 
5.  public classNameSortimplementsComparator\{
6.  @Override *//两个参数是泛型的对象*
7.  publicintcompare(Student o1, Student o2)\{
8.  *//按照姓名的升序排列，前面加个负号就按照降序排列*
9.  return o1.getName().compareTo(o2.getName());
10. \}
11. \}

（3）创建按照年龄升序排列的实现类

1.  package com.xykj.comparatorTest;
2.  import java.util.Comparator;
3.  *//按照年龄的升序排列 实现接口 泛型是自定义类，里面有要排序的内容* 
4.  public classAgeSortimplementsComparator\{
5.  
6.  @Override *//两个参数是泛型的对象*
7.  publicintcompare(Student o1, Student o2)\{
8.  *//按照姓名的升序排列，前面加个负号就按照降序排列*
9.  return o1.getAge()-o2.getAge();
10. \}
11. \}

（4）对ArrayList进行排序

1.  package com.xykj.comparatorTest;
2.  import java.util.ArrayList;
3.  import java.util.Collections;
4.  public classMainClass \{ 
5.  */\*\**
6.   *\* comparator的使用* 
7.   *\* \*/*
8.  publicstaticvoidmain(String\[\] args)\{
9.  ArrayList list = new ArrayList<>();
10. list.add( new Student( "1wenzhi", 18));
11. list.add( new Student( "3wenzhi", 19));
12. list.add( new Student( "2wenzhi", 33));
13. list.add( new Student( "66wenzhi", 10));
14. list.add( new Student( "4wenzhi", 18));
15. System.out.println( "=========排序前=======");
16. for (Student student : list) \{
17. System.out.println(student);
18. \}
19. 
20. *// 按照年龄升序排列*
21. Collections.sort( list, new AgeSort());
22. System.out.println( "=========排序后=======");
23. 
24. for (Student student : list) \{
25. System.out.println(student);
26. \}
27. \}
28. \}

运行结果：

![20160910134230070][]

可以看到添加数乱序添加的，正常打印是按照添加的顺序打印的，排序后就可以得到想要的结果

（5）对LinkedList进行排序

1.  package com.xykj.comparatorTest;
2.  
3.  import java.util.Collections;
4.  import java.util.LinkedList;
5.  
6.  public classLinkedListMainClass \{ 
7.  */\*\**
8.   *\* comparator的使用*
9.   *\* LinkedList和ArrayList使用方法一样的*
10. *\* 这里显示按照姓名排列*
11.  *\* \*/*
12. publicstaticvoidmain(String\[\] args)\{
13. LinkedList< Student> list=newLinkedList<>();
14. list.add( new Student( "1liwenzhi", 18));
15. list.add( new Student( "3liwenzhi", 19));
16. list.add( new Student( "2liwenzhi", 33));
17. list.add( new Student( "88liwenzhi", 10));
18. list.add( new Student( "66liwenzhi", 18));
19. System.out.println( "=========排序前=======");
20. for (Student student : list) \{
21. System.out.println(student);
22. \}
23. *//按照姓名升序排列*
24. Collections.sort( list, new NameSort());
25. System.out.println( "=========排序后=======");
26. for (Student student : list) \{
27. System.out.println(student);
28. \}
29. \}
30. \}

运行结果：

![20160910135222632][]

添加的顺序是杂乱的，排序后按照姓名的升序排列

Collections.sort方法只能对List接口下的实现类进行排序，对Set接口下的实现类不能进行排序，请看下面图片的示例：

![20160910135319442][]

三．最后的总结

（一）上面对Comparable接口和Comparator接口的使用方法和示例，都有很详细的描述。

（二）对java集合的各个实现类的排序方法也有比较详细的介绍。

（三）其实无论什么集合的数据通过一些方法都能排序，比如Set接口下的实现类的，可以把它们的数据先保存到List接口下的实现类里面，然后再通过Collections.sort的方法排序显示出来。

（四）排序在实际程序的应用也是很有用处的，比如显示显示商品按照距离最近来显示还是按照人气值来显示，都可以用排序来操作后显示。

（五）总而言之，至少要掌握一种排序方式。

转载自 [https://blog.csdn.net/wenzhi20102321/article/details/52494402][https_blog.csdn.net_wenzhi20102321_article_details_52494402]

[20160910130143170]: /images/20220521/e95a8d702dfd44249f1ee110450d892a.png
[20160910130720787]: /images/20220521/37f5f0dfdbd4439cb2c74818e4dfc182.png
[20160910130916243]: /images/20220521/f19dea1ccdd64814b9599898775d5def.png
[20160910131046252]: /images/20220521/4b950955e2834976bd18ed9cbf99ef62.png
[20160910131136908]: /images/20220521/a192c8f56e784c02b9be98da7d8c363c.png
[20160910131419597]: /images/20220521/03b1bf57e1064b14877cfb0b7bd014bd.png
[20160910134230070]: /images/20220521/862df7da71314739952f2d9524620342.png
[20160910135222632]: /images/20220521/6d92626252a94d739a805e3c6dbc1187.png
[20160910135319442]: /images/20220521/97ef88b39ebe46b8b2c0b70c34a8fcf2.png
[https_blog.csdn.net_wenzhi20102321_article_details_52494402]: https://blog.csdn.net/wenzhi20102321/article/details/52494402