Java教程

集合进行排序的两种方式

本文主要是介绍集合进行排序的两种方式,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

方法1:自然排序(实现comparable接口compareto方法)

方法2:自定义排序(Comparator接口、compare方法)

一、自然排序

1Comparable是在集合内部定义的方法实现的排序,位于java.util下。

2如果创建一个集合来储存对象,当存储的对象是Integer类型、String类型时,因为这些类型已经实现了Comparable接口. 所以遍历输出这个集合时会按照这些类的重写的compareTo()方法来顺序输出。List<String> list1 = new ArrayList<>();

 

3、如果我们想要排序一个自定义类,或者让一个自定义类可以比较大小就需要该类实现Comparable接口,重写compareto()方法。

4、TreeSet类的排序

  1 package text;
  2 
  3  
  4 
  5 import java.util.Iterator;
  6 
  7 import java.util.Set;
  8 
  9 import java.util.TreeSet;
 10 
 11  
 12 
 13 public class Main {
 14 
 15  
 16 
 17     public static void main(String[] args) {
 18 
 19         Set set = new TreeSet();
 20 
 21         People p1 = new People(1, 18,"小明");
 22 
 23         People p2 = new People(2, 5,"大壮");
 24 
 25         People p3 = new People(3, 20,"小红");
 26 
 27        
 28 
 29         set.add(p1);
 30 
 31         set.add(p2);
 32 
 33         set.add(p3);
 34 
 35        
 36 
 37         Iterator it=set.iterator();
 38 
 39         while(it.hasNext()){
 40 
 41             System.out.println(it.next());
 42 
 43         }
 44 
 45     }
 46 
 47  
 48 
 49 }
 50 
 51  
 52 
 53 package text;
 54 
 55  
 56 
 57 public class People implements Comparable{
 58 
 59      int id;
 60 
 61      int age;
 62 
 63      String name;
 64 
 65      
 66 
 67     public People(int id, int age, String name) {
 68 
 69         super();
 70 
 71         this.id = id;
 72 
 73         this.age = age;
 74 
 75         this.name = name;
 76 
 77     }
 78 
 79  
 80 
 81     @Override
 82 
 83     public String toString() {
 84 
 85         return "people [id=" + id + ", age=" + age + ", name=" + name + "]";
 86 
 87     }
 88 
 89  
 90 
 91  
 92 
 93     @Override
 94 
 95     public int compareTo(Object o) {
 96 
 97         People p;
 98 
 99         if(o instanceof People){
100 
101             p = (People)o;
102 
103         }else{
104 
105             return -1;
106 
107         }
108 
109         int diff = this.age - p.age;
110 
111         if(diff!=0){
112 
113             diff = diff / Math.abs(diff);
114 
115         }
116 
117         return diff;
118 
119     }
120 
121    
122 
123  
124 
125 }

 

 

5、HashSet

(1)HashSet类的使用,不支持对元素数据进行排序

(2)即使自定义的类实现了comparable接口,但是结果还是不排序

6、ArrayList的排序(LInkedList的排序类似)

 1 package com.xykj.comparable;
 2 
 3 public class User implements Comparable
 4 
 5   
 6 
 7      {//这里的User是后面集合类的泛型
 8 
 9     String name = "";
10 
11     String password = "";
12 
13     public User(String name, String password) {
14 
15        this.name = name;
16 
17        this.password = password;
18 
19     }
20 
21     // 实现排序必须要重写的方法
22 
23     @Override
24 
25     public int compareTo(User o) {//按照密码的升序排列,想要按照名字排序就把password换成name就可以了
26 
27        return password.compareTo(o.password);
28 
29     }
30 
31     // 重写toString方法
32 
33     @Override
34 
35     public String toString() {
36 
37        return name + "    " + password;
38 
39     }
40 
41 }
42 
43  
44 
45  
46 
47 package com.xykj.comparable;
48 import java.util.ArrayList;
49 
50 import java.util.Collections;
51 
52 public class ArrayListTest {
53 
54     //对ArrayList排序必须要使用Collections.sort(list),否则不会排序,
55 
56     //会按照添加的顺序打印出来
57 
58     public static void main(String[] args) {
59 
60        ArrayList
61 
62   
63 
64      list = new ArrayList<>();
65 
66        for (int i = 1; i <= 10; i++) {
67 
68            list.add(new User("ArrayList_name" + i, " ArrayList_password" + (50 - i)));
69 
70        }
71 
72        Collections.sort(list);//如果注释后,输入输出不改变
73 
74        for (User user : list) {
75 
76            System.out.println(user.toString());
77 
78        }
79 
80     }
81 
82 }

结果:

 

 升序输入,降序输出

二、自定义排序

1、Comparator是在集合外部实现的排序,位于java.lang下,是一个专用的比较器。当这个对象不支持自比较或者自比较函数不能满足要求时,可写一个比较器来完成两个对象之间大小的比较。

2、Comparator体现了一种策略模式(strategy design pattern),就是不改变对象自身,而用一个策略对象(strategy object)来改变它的行为。使用方法只能用Collections类的sort方法,并且是传递两个参数进去(List list,Class class),第一个参数是集合的对象list,第二个是实现了comparator接口的实现类的对象。

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

4、使用方法:

 

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

 

    (2)要重写compare方法,比较Object里面的具体属性用compareTo

 

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

5.Comparator的示例

 

(1)先建一个基本属性类

 

 1 package com.xykj.comparatorTest;
 2 
 3 public class Student {
 4 
 5     //创建两个基本属性
 6 
 7     String name="";
 8 
 9     int age=0;
10 
11   
12 
13     //从写构造方法用来传递数据
14 
15     public Student(String name, int age) {
16 
17        super();
18 
19        this.name = name;
20 
21        this.age = age;
22 
23     }
24 
25     //从写toString方法,方便显示
26 
27     @Override
28 
29     public String toString() {
30 
31        return name + "  " + age ;
32 
33     }
34 
35   
36 
37     //基本属性的get和set方法
38 
39     public String getName() {
40 
41        return name;
42 
43     }
44 
45     public void setName(String name) {
46 
47        this.name = name;
48 
49     }
50 
51     public int getAge() {
52 
53        return age;
54 
55     }
56 
57     public void setAge(int age) {
58 
59        this.age = age;
60 
61     }
62 
63   
64 
65 }
66 
67  

 

(2)创建按照姓名升序排列的实现类

 

 1 package com.xykj.comparatorTest;
 2 
 3  
 4 
 5 import java.util.Comparator;
 6 
 7        //按照名字的升序排列    实现接口       泛型是自定义类,里面有要排序的内容  
 8 
 9 public class NameSort implements Comparator
10 
11   
12 
13     {
14 
15     @Override         //两个参数是泛型的对象
16 
17     public int compare(Student o1, Student o2) {
18 
19                   //按照姓名的升序排列,前面加个负号就按照降序排列
20 
21        return o1.getName().compareTo(o2.getName());
22 
23     }
24 
25 }
26 
27   

 

(3)创建按照年龄升序排列的实现类

 

 

 1 package com.xykj.comparatorTest;
 2 
 3 import java.util.Comparator;
 4 
 5 //按照年龄的升序排列     实现接口          泛型是自定义类,里面有要排序的内容 
 6 
 7 public class AgeSort implements Comparator
 8 
 9   
10 
11     {
12 
13  
14 
15     @Override         //两个参数是泛型的对象
16 
17     public int compare(Student o1, Student o2) {
18 
19        //按照姓名的升序排列,前面加个负号就按照降序排列
20 
21        return o1.getAge()-o2.getAge();
22 
23     }
24 
25 }

 

(4)对ArrayList进行排序

 

 

 1 package com.xykj.comparatorTest;
 2 
 3 import java.util.ArrayList;
 4 
 5 import java.util.Collections;
 6 
 7 public class MainClass {
 8 
 9     /**
10 
11      * comparator的使用 
12 
13      * */
14 
15     public static void main(String[] args) {
16 
17        ArrayList
18 
19   
20 
21      list = new ArrayList<>();
22 
23        list.add(new Student("1wenzhi", 18));
24 
25        list.add(new Student("3wenzhi", 19));
26 
27        list.add(new Student("2wenzhi", 33));
28 
29        list.add(new Student("66wenzhi", 10));
30 
31        list.add(new Student("4wenzhi", 18));
32 
33        System.out.println("=========排序前=======");
34 
35        for (Student student : list) {
36 
37            System.out.println(student);
38 
39        }
40 
41  
42 
43         // 按照年龄升序排列
44 
45        Collections.sort(list, new AgeSort());
46 
47        System.out.println("=========排序后=======");
48 
49  
50 
51        for (Student student : list) {
52 
53            System.out.println(student);
54 
55        }
56 
57     }
58 
59 }

 

   结果

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

 

Collections.sort方法只能对List接口下的实现类进行排序,对Set接口下的实现类不能进行排序

 

这篇关于集合进行排序的两种方式的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!