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

最新推荐文章于 2022-09-06 00:46:43 发布

峥嵘life

最新推荐文章于 2022-09-06 00:46:43 发布

阅读量1.7w

点赞数 19

分类专栏： java java集合文章标签： java集合 java java基础 Comparator Comparable

本文链接：https://blog.csdn.net/wenzhi20102321/article/details/52494402

版权

java 同时被 2 个专栏收录

104 篇文章 14 订阅

订阅专栏

java集合

4 篇文章 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

package com.xykj.comparable;
public class User implements Comparable
   
   
    
     {//这里的User是后面集合类的泛型
    String name = "";
    String password = "";
    public User(String name, String password) {
       this.name = name;
       this.password = password;
    }
    // 实现排序必须要重写的方法
    @Override
    public int compareTo(User o) {//按照密码的升序排列，想要按照名字排序就把password换成name就可以了
       return password.compareTo(o.password);
    }
    // 重写toString方法
    @Override
    public String toString() {
       return name + "    " + password;
    }
}

（2）TreeSet类的排序

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

运行结果：

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

（3）HashSet的演示

package com.xykj.comparable;
import java.util.HashSet;
public class HashSetTest {
    // HashSet类的使用，不支持对元素数据进行排序
    public static void main(String[] args) {
       //即使泛型User类实现了comparable接口，但是结果还是没有排序
       HashSet
   
   
    
     hSet = new HashSet<>();
        for (int i = 1; i <= 10; i++) {
           //即使泛型User类没有实现了comparable接口，add方法也不会报错
           hSet.add(new User("hSet_name" + i, "hSet_password" + (50 - i)));
       }
       for (User user : hSet) {
           System.out.println(user.toString());
       }
    }
}

运行结果：

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

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

package com.xykj.comparable;
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListTest {
    //对ArrayList排序必须要使用Collections.sort(list)，否则不会排序，
    //会按照添加的顺序打印出来
    public static void main(String[] args) {
       ArrayList
   
   
    
     list = new ArrayList<>();
       for (int i = 1; i <= 10; i++) {
           list.add(new User("ArrayList_name" + i, " ArrayList_password" + (50 - i)));
       }
       //Collections.sort(list);先注释看看结果
       for (User user : list) {
           System.out.println(user.toString());
       }
    }
}

运行结果：

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

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

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

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

（5）LInkedList的排序

package com.xykj.comparable;
import java.util.Collections;
import java.util.LinkedList;
public class LinkedListTest {
    //LinkedList的排序
    public static void main(String[] args) {
       LinkedList
   
   
    
     list = new LinkedList<>();
       for (int i = 1; i <= 10; i++) {
           list.add(new User("LinkedList_name" + i, "LinkedList_password" + (50 - i)));
       }
       //使用sort方法排序
       Collections.sort(list);
       for (User user : list) {
           System.out.println(user.toString());
       }
    }
}

运行结果：

效果和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）先建一个基本属性类

package com.xykj.comparatorTest;
public class Student {
    //创建两个基本属性
    String name="";
    int age=0;
   
    //从写构造方法用来传递数据
    public Student(String name, int age) {
       super();
       this.name = name;
       this.age = age;
    }
    //从写toString方法，方便显示
    @Override
    public String toString() {
       return name + "  " + age ;
    }
   
    //基本属性的get和set方法
    public String getName() {
       return name;
    }
    public void setName(String name) {
       this.name = name;
    }
    public int getAge() {
       return age;
    }
    public void setAge(int age) {
       this.age = age;
    }
   
}

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

package com.xykj.comparatorTest;
 
import java.util.Comparator;
       //按照名字的升序排列    实现接口       泛型是自定义类，里面有要排序的内容   
public class NameSort implements Comparator
   
   
    
    {
    @Override         //两个参数是泛型的对象
    public int compare(Student o1, Student o2) {
                  //按照姓名的升序排列，前面加个负号就按照降序排列
       return o1.getName().compareTo(o2.getName());
    }
}

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

package com.xykj.comparatorTest;
import java.util.Comparator;
//按照年龄的升序排列     实现接口          泛型是自定义类，里面有要排序的内容  
public class AgeSort implements Comparator
   
   
    
    {
 
    @Override         //两个参数是泛型的对象
    public int compare(Student o1, Student o2) {
       //按照姓名的升序排列，前面加个负号就按照降序排列
       return o1.getAge()-o2.getAge();
    }
}

（4）对ArrayList进行排序

package com.xykj.comparatorTest;
import java.util.ArrayList;
import java.util.Collections;
public class MainClass {
    /**
     * comparator的使用  
     * */
    public static void main(String[] args) {
       ArrayList
   
   
    
     list = new ArrayList<>();
       list.add(new Student("1wenzhi", 18));
       list.add(new Student("3wenzhi", 19));
       list.add(new Student("2wenzhi", 33));
       list.add(new Student("66wenzhi", 10));
       list.add(new Student("4wenzhi", 18));
       System.out.println("=========排序前=======");
       for (Student student : list) {
           System.out.println(student);
       }
 
        // 按照年龄升序排列
       Collections.sort(list, new AgeSort());
       System.out.println("=========排序后=======");
 
       for (Student student : list) {
           System.out.println(student);
       }
    }
}

运行结果：

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

（5）对LinkedList进行排序

package com.xykj.comparatorTest;
 
import java.util.Collections;
import java.util.LinkedList;
 
public class LinkedListMainClass {
   /**
    * comparator的使用
    * LinkedList和ArrayList使用方法一样的
* 这里显示按照姓名排列
    * */
   public static voidmain(String[] args) {
        LinkedList< Student> list=newLinkedList<>();
        list.add(new Student("1liwenzhi",18));
        list.add(new Student("3liwenzhi",19));
        list.add(new Student("2liwenzhi",33));
        list.add(new Student("88liwenzhi",10));
        list.add(new Student("66liwenzhi",18));
        System.out.println("=========排序前=======");
        for (Student student : list) {
           System.out.println(student);
        }
        //按照姓名升序排列
         Collections.sort(list,new NameSort());
        System.out.println("=========排序后=======");
          for (Student student : list) {
           System.out.println(student);
        }
   }
}

运行结果：