本文共 4676 字，大约阅读时间需要 15 分钟。

作用：

实现列表排序。

缺点：

Comparable和目标类的耦合度太高，如果对比较算法不满意，或者目标类没有实现Comparable接口，就得对原来的代码进行修改，这一点不符合设计模式的开闭原则（对扩展开放，对修改关闭）

使用规则：

让我们列表的Bean implements Comparable , 有一个方法需要我们实现，如下：

@Override    public int compareTo(Object o) {
           return 0;    }

方法原理：利用当前对象和传入的目标对象进行比较，通过返回值，决定顺序。

当返回值是 “-1”，代表从大到小排序；

当返回值是 “1”，代表从小到大排序；

当返回值是 “0”，两对象相等；

当使用实现我们接口的Bean，需要排序的时候：

Collections.sort(list);

就可以了。

事例：

1.从大到小排序，并且只有一种判断条件

我们的Bean：

public class ComparableBean implements Comparable {
       private int first;    private int second;    private int third;    public int getFirst() {
           return first;    }    public void setFirst(int first) {
           this.first = first;    }    public int getSecond() {
           return second;    }    public void setSecond(int second) {
           this.second = second;    }    public int getThird() {
           return third;    }    public void setThird(int third) {
           this.third = third;    }    @NonNull    @Override    public String toString() {
           return "ComparableBean{" +                "first=" + first +                ", second=" + second +                ", third=" + third +                '}';    }    @Override    public int compareTo(Object object) {
           if (this.first > ((ComparableBean) object).first) {
               return -1;        } else if (this.first < ((ComparableBean) object).first) {
               return 1;        } else {
               return 0;        }    }}

我们的Activity：

public class ComparableActivity extends BaseActivity {
       public static void start(Context context) {
           context.startActivity(new Intent(context, ComparableActivity.class));    }    ArrayList
   
     arrayList = new ArrayList<>();    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);        ComparableBean bean1 = new ComparableBean();        bean1.setFirst(2);        ComparableBean bean2 = new ComparableBean();        bean2.setFirst(100);        ComparableBean bean3 = new ComparableBean();        bean3.setFirst(11);        arrayList.add(bean1);        arrayList.add(bean2);        arrayList.add(bean3);        System.out.println("打印排序前 列表 ="+arrayList.toString());        Collections.sort(arrayList);        System.out.println("打印排序后 列表 ="+arrayList.toString());    }}
   

Log：

System.out: 打印排序前 列表 =[ComparableBean{
   first=2, second=0, third=0}, ComparableBean{
   first=100, second=0, third=0},  ComparableBean{
   first=11, second=0, third=0}]System.out: 打印排序后 列表 =[ComparableBean{
   first=100, second=0, third=0}, ComparableBean{
   first=11, second=0, third=0},  ComparableBean{
   first=2, second=0, third=0}]

可以看到，我们已经实现了排序，是从大到小排序没有错了。

2.多条件排序

现在，有另一个需求了：第一个条件相等的时候，我想判断第二个条件，谁小谁在前面，怎么修改？

修改 int compareTo(Object object) 方法：

@Override    public int compareTo(Object object) {
           if (this.first > ((ComparableBean) object).first) {
               return -1;        } else if (this.first < ((ComparableBean) object).first) {
               return 1;        } else {
               if (this.second > ((ComparableBean) object).second) {
                   return 1;            } else if (this.second < ((ComparableBean) object).second) {
                   return -1;            } else {
                   return 0;            }        }    }

修改Activity：

@Override    protected void onCreate(@Nullable Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);        ComparableBean bean1 = new ComparableBean();        bean1.setFirst(2);        ComparableBean bean2 = new ComparableBean();        bean2.setFirst(100);        ComparableBean bean3 = new ComparableBean();        bean3.setFirst(11);        bean3.setSecond(81);        ComparableBean bean4 = new ComparableBean();        bean4.setFirst(11);        bean4.setSecond(9);        arrayList.add(bean1);        arrayList.add(bean2);        arrayList.add(bean3);        arrayList.add(bean4);        System.out.println("打印排序前 列表 =" + arrayList.toString());        Collections.sort(arrayList);        System.out.println("打印排序后 列表 =" + arrayList.toString());    }

Log：

I/System.out: 打印排序前 列表 =[ComparableBean{
   first=2, second=0, third=0}, ComparableBean{
   first=100, second=0, third=0}, ComparableBean{
   first=11, second=81, third=0}, ComparableBean{
   first=11, second=9, third=0}]I/System.out: 打印排序后 列表 =[ComparableBean{
   first=100, second=0, third=0}, ComparableBean{
   first=11, second=9, third=0}, ComparableBean{
   first=11, second=81, third=0}, ComparableBean{
   first=2, second=0, third=0}]

如果还有其他条件，以此类推~

扩展：

Comparable在排序上用的比较多，所以很多人对它有误解。其实Comparable是一个比较器，只是用来比较两个对象的区别，除了排序，它还可以用来进行分组（还有其他作用，这里不深究）

参考地址：

转载地址：https://blog.csdn.net/weixin_35691921/article/details/103317761 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！