关于comparator升序、降序

1.几种情况说明： 

/**
*    排序结果为升序
*/
public int compare(int i1,int i2){
    retrun i1 - i2 ;
}

/**
*    排序结果为降序
*/
public int compare(int i1,int i2){
    retrun i2 - i1;
}

/**
*    排序结果为升序
*    定义Role类中有id属性
*/
public int compareTo(Role role){
    retrun this.id- role.id;
}

/**
*    排序结果为降序
*/
public int compareTo(Role role){
    retrun role.id- this.id;
}

为什么public int compare（int i1，int i2）{...}中return i1 - i2则为升序，而return i2 -i1则为降序呢？

2.个人理解

首先我们得先了解这几个方法中的返回值大于0、等于0、小于0的作用是什么：

返回值小于0：升序；

返回值等于0：不做位置交换；

返回值大于0：降序；

我们一般在重写compareTo方法的时候会将小于0的情况归结为rerun -1，将大于0的情况归结为return 1；

知道上面返回值的作用后，我们可以这么理解：

/**
*    方法参数i1在i2前面，则理解成此方法定义的规则是i1 < i2
*        此时若我们要定义升序，则使此方法的返回值为小于0，则可return i1 - i2；
*        此时若我们要定义降序，则使此方法的返回值为大于0，则可return i2 - i1； 
*/
public int compare(int i1,int i2){
    ...
}

/**
*    方法参数i2在i1前面，则理解成此方法定义的规则是i2 < i1
*        此时若我们要定义升序，则使此方法的返回值为小于0，则可return i2 -i1；
*        此时若我们要定义降序，则使此方法的返回值为大于0，则可return i1 - i2；
*/
public int compare(int i2,i1){
    ...
}

/**
*    方法这样定义，则理解成this.id < role.id
*        此时若我们要定义升序，则使此方法的返回值小于0，则可return this.id - role.id
*        此时若我们要定义降序，则使此方法的返回值大于0，则可return role.id - this.id
*/
public int compareTo(Role role){
    ...
}

理解了上面方法怎么写，就定义了怎样的规则后，我们就可以理解第一部分中升序、降序是怎么定义的。

3.测试代码

@NoArgsConstructor
@AllArgsConstructor
@Data
@Builder
@Accessors(chain = true)
public class Role {

    private Long id;
    private Long insertTime;
    private Long updateTime;
    private String roleName;


    public static void main(String[] args) {

        Role build1 = Role.builder().id(10L).build();
        Role build2 = Role.builder().id(15L).build();
        Role build3 = Role.builder().id(5L).build();

        TreeSet<Role> roles = new TreeSet<Role>(new Comparator<Role>() {
            @Override
            public int compare(Role o1, Role o2) {
                Integer i1 = Integer.parseInt(String.valueOf(o1.id));
                Integer i2 = Integer.parseInt(String.valueOf(o2.id));
               //因为o1.id<o2.id，即i1<i2
               //所以定义降序只需将返回值定义为大于0即可
               //输出结果为降序
                return i2-i1;
            }
        }) {
            {
                this.add(build1);
                this.add(build2);
                this.add(build3);
            }
        };


        for (Role role : roles) {
            System.out.println(role);
        }
    }
}

===================输出结果===================
Role(id=15, insertTime=null, updateTime=null, roleName=null)
Role(id=10, insertTime=null, updateTime=null, roleName=null)
Role(id=5, insertTime=null, updateTime=null, roleName=null)