【Java】Collections.sort() 方法 —— Comparable、Comparator接口

系统管理员 2022-03-21 04:57 277阅读 0赞

**前言**：

> 在日常开发中，很多时候都需要对一些数据进行排序的操作。然而那些数据一般都是放在一个集合中如：`Map ，Set ，List`等集合中。他们都提共了一个排序方法`sort()`，要对数据排序直接使用这个方法就行，但是要保证集合中的对象是 可比较的。

### 一、 Collections.sort() 方法 ###

#### 1. 概述 ####

Collections类中的sort方法可以实现对List接口的集合进行排序。这个方法假定列表元素实现了Comparable接口。  
查看Java官方文档可知，sort方法有两种重载形式方法。  
第一种：

static <T extends Comparable<? super T>> void sort(List<T> list)

第二种：

public static <T> void sort(List<T> list,Comparator<? super T> c)

#### 2 . 举例子 ####

（1）程序：（升序）

/*
    *  对数组中的数进行升序排序
    * @author WTCLAB_yd
    */
    import java.util.*;
    public class test2 {
        
    
        public static void main(String[] args) {
        
            
            Scanner scan = new Scanner(System.in);
            List<Integer> list = new ArrayList<>();          
            
            //用户输入10个整数
            System.out.println("请输入10个整数：");
            for(int i = 0; i < 10; i++)                      
            {
        
                list.add(scan.nextInt());//将输入的数添加到数组
            }
            scan.close();
            
            //排序
            Collections.sort(list);
            
            //输出排序结果
           System.out.println(list);
        }
    
    }

结果演示：  
![在这里插入图片描述][20190130192757879.png]  
（2）降序排序，所以可以通过将Collections.reverseOrder()作为sort方法的第二个参数来实现  
程序：

import java.util.*;
    public class test3 {
        
    
        public static void main(String[] args) {
        
            
            Scanner scan = new Scanner(System.in);
            List<Integer> list = new ArrayList<>();          
            
            //用户输入10个整数
            System.out.println("请输入10个整数：");
            for(int i = 0; i < 10; i++)                      
            {
        
                list.add(scan.nextInt());
            }
            scan.close();
            
            //排序
            Collections.sort(list,Collections.reverseOrder());
            
            //输出排序结果
           System.out.println(list);
        }
    
    }

结果演示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdkYW4xMDI1_size_16_color_FFFFFF_t_70]  
`在上面的例子中，列表中的元素是整数，所以排序逻辑是很显然的：如果是升序排序，那就小数在前，大数在后。但是，如果排序的对象并非属于整数、浮点数之类的基本数据类型，那么这些对象之间的“大小”关系该如何定义？此时就要用到`

### 二、 Comparable接口 ###

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。

若一个类实现了Comparable接口，就意味着“该类支持排序”。 假设“有一个List列表(或数组)，里面的元素是实现了Comparable接口的类”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。

此外，“实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素，而不需要指定比较器。

compareTo方法的返回值是int，有三种情况：  
（1）比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数  
（2）比较者等于被比较者，那么返回0  
（3）比较者小于被比较者，那么返回负整数

### 三、Comparator接口 ###

#### 1. 概述 ####

> Comparator可以认为是是一个外比较器，有两种情况可以使用实现Comparator接口的方式：  
> （1）一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较  
> （2）一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式

Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：

(1) o1大于o2，返回正整数

(2) o1等于o2，返回0

(3) o1小于o2，返回负整数

/*
    *Comparator复写方法
    */
    
    Collections.sort(list, new Comparator<Student>() {
        
        @Override
        public int compare(Student o1, Student o2) {
        
            return o1.getId() - o2.getId();
        }
    };

compare(Student o1, Student o2) 方法的返回值跟 Comparable<> 接口中的 compareTo(Student o) 方法 返回值意思相同。另一种写法如下：

/*
    *Comparator复写方法
    */
    list.sort(new Comparator<Student>() {
        
        @Override
        public int compare(Student o1, Student o2) {
        
            return o1.getId() - o2.getId();
        }
    });

#### 2. 举例子 ####

（1）程序：

/*
     * 将数组中的值按升/降序排序
     * @author WTCLAB_yd
     */
     import java.io.*;//导入io类包
    import java.util.*;//导入util类包
     public class test4 {
        
    	public static void main(String[] args) {
        
    		List<String> list = new ArrayList<String>();//定义动态数组
            list.add("45");//向数组中加入字符串
            list.add("56");
            list.add("10");
            list.add("9");
            list.add("25");
     
            System.out.println( "---------------升序排列----------------" );
            // 升序排列
            Collections.sort(list, new Comparator<String>() {
        
                @Override
    			//自定义重写方法
                public int compare(String o1, String o2) {
        
                    int num1 = Integer.parseInt(o1);//将String字符类型数据转换为Integer整型数据
                    int num2 = Integer.parseInt(o2);
                    if (num1 > num2) {
        //从数组中获取的数依次对比:大于返回1，小于返回-1，等于返回0			
                        return 1;		
                    } else if (num1 < num2) {
        
                        return -1;
                    } else {
        
                        return 0;
                    }
                }
            });
     
            for (String str : list) {
        //遍历出排好序的数组中的值
                System.out.println(str);
            }
     
            System.out.println( "---------------降序排列----------------" );
            // 降序排列
            Collections.sort(list, new Comparator<String>() {
        
                @Override
                public int compare(String o1, String o2) {
        
                    int num1 = Integer.parseInt(o1);
                    int num2 = Integer.parseInt(o2);
                    if (num1 < num2) {
        
                        return 1;
                    } else if (num1 > num2) {
        
                        return -1;
                    } else {
        
                        return 0;
                    }
                }
            });
     
            for (String str : list) {
        
                System.out.println(str);
            }
        }
     }

（2）结果演示  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdkYW4xMDI1_size_16_color_FFFFFF_t_70 1]

### 四、总结 ###

两种比较器Comparable和Comparator，后者相比前者有如下优点：

1、如果实现类没有实现Comparable接口，又想对两个类进行比较（或者实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意），那么可以实现Comparator接口，自定义一个比较器，写比较算法

2、实现Comparable接口的方式比实现Comparator接口的耦合性 要强一些，如果要修改比较算法，要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修 改。从这个角度说，其实有些不太好，尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。实际上实现Comparator 接口的方式后面会写到就是一种典型的策略模式。

[20190130192757879.png]: /images/20220321/eb7f2c6a8e984e659620917bb8b0cd5b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdkYW4xMDI1_size_16_color_FFFFFF_t_70]: /images/20220321/788da5ddf96d48d5a4f5ba691ffc6547.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdkYW4xMDI1_size_16_color_FFFFFF_t_70 1]: /images/20220321/b7ad2d6d432944deb3e72808cbdf2931.png