如何在android或java中实现comparator对对象进行排序

让我从以下示例开始：

public void loadList(ArrayList<Calls> list) {
    List<Calls> calls = new ArrayList<Calls>();
    calls.addAll(list);
}

我想根据

ms

字段按升序或降序对上面的

列表进行排序。我遇到了一些
比较器的示例，但仍然不清楚。
类MSComaparator实现了比较器{
class MSComaparator implements Comparator<Calls>{

        @Override
        public int compare(Calls lhs, Calls rhs) {
            // TODO Auto-generated method stub
            return lhs.ms-rhs.ms;
        }

    }

    class NameComaparator implements Comparator<Calls>{

        @Override
        public int compare(Calls lhs, Calls rhs) {
            // TODO Auto-generated method stub
            return lhs.name.comapreTo(rhs.name);
        }

    }

@凌驾
公共整数比较（调用lhs、调用rhs）{
//TODO自动生成的方法存根
返回lhs.ms-rhs.ms；
}
}
类namecomparator实现了Comparator{
@凌驾
公共整数比较（调用lhs、调用rhs）{
//TODO自动生成的方法存根
返回lhs.name.comapreTo（rhs.name）；
}
}

并致电：

public void loadList(ArrayList<Calls> list) {
    List<Calls> calls = new ArrayList<Calls>();
    calls.addAll(list);
    Collections.sort(calls,new MSComaparator())
}

public void加载列表（ArrayList列表）{
列表调用=新建ArrayList（）；
calls.addAll（列表）；
Collections.sort（调用，新的MSComaparator（））
}

如果您只想根据ns进行排序，可以简单实现：

public class Calls implements Comparable<Calls>{
    public long ms;
    public name;     
    @Override
        public int compareTo(Calls  another) {
            // TODO Auto-generated method stub
            return this.ms>another.ms;
        }
} 

公共类调用实现了可比较的{
公共长ms；
公共名称；
@凌驾
公共整数比较（调用另一个）{
//TODO自动生成的方法存根
返回此.ms>另一个.ms；
}
} 

并致电：

public void loadList(ArrayList<Calls> list) {
    List<Calls> calls = new ArrayList<Calls>();
    calls.addAll(list);
    Collections.sort(calls)
}

public void加载列表（ArrayList列表）{
列表调用=新建ArrayList（）；
calls.addAll（列表）；
Collections.sort（调用）
}
只需通过以下方式实现比较器：

private class CallsComparator implements Comparator<Calls> {

    @Override
    public int compare(Calls calls1, Calls calls2) {
      //Swap calls1 with 2
      return 1;
      //Spap 2 with 1
      return -1;
      // do nothing
      return 0;
    }

  }

请参见下面的示例

class CallsComp implements Comparator<Calls>{

    @Override
    public int compare(Calls c1, Calls c2) {
        if(c1.getMs() < c2.getMs()){
            return 1;
        } else {
            return -1;
        }
    }
}

类CallsComp实现Comparator{
@凌驾
公共整数比较（调用c1，调用c2）{
if（c1.getMs（）
调用
类需要实现
compariable
接口并实现
comparieto
方法：

public class Calls implements Comparable<Calls> {
   public long ms;
   public name;

   @Override
   public int compareTo(Calls call) {
       // Prepend a -1 for inverse order
       return Long.compare(this.ms,call.ms);
   }
} 

公共类调用实现了可比较的{
公共长ms；
公共名称；
@凌驾
公共整数比较（调用）{
//为逆序预加a-1
返回Long.compare（this.ms，call.ms）；
}
} 

然后只需调用集合。排序（调用）
即可对列表进行排序。
我想这会有所帮助

public void loadList(ArrayList<Calls> list) {
    List<Calls> calls = new ArrayList<Calls>();
    calls.addAll( list );

    // Ascending Order
    Collections.sort(calls, new Comparator<Calls>() {

        @Override
        public int compare(Calls o1, Calls o2) {
            return (int)(o1.ms-o2.ms);
        }
    });
    // Descending Order
    Collections.sort(calls, new Comparator<Calls>() {

        @Override
        public int compare(Calls o1, Calls o2) {
            return (int)(o2.ms-o1.ms);
        }
    });
}

public void加载列表（ArrayList列表）{
列表调用=新建ArrayList（）；
calls.addAll（列表）；
//升序
Collections.sort（调用，新的Comparator（）{
@凌驾
公共整数比较（调用o1，调用o2）{
返回（int）（o1.ms-o2.ms）；
}
});
//降序
Collections.sort（调用，新的Comparator（）{
@凌驾
公共整数比较（调用o1，调用o2）{
返回（int）（o2.ms-o1.ms）；
}
});
}
@ARP

我知道现在回答这个问题已经太晚了，但我最近在我的项目中实现了同样的东西，所以我想我应该和你们分享

因此，在添加列表后的
函数中，您可以做的是

public void loadList(ArrayList<Calls> list) {
    List<Calls> calls = new ArrayList<Calls>();
    calls.addAll(list);
    Collections.sort(calls, new Comparator<Calls>() {
                @Override
                public int compare(Calls o, Calls t1) {
                    return (int) (o.getMS() - t1.getMS());
                }
            });
}

public void加载列表（ArrayList列表）{
列表调用=新建ArrayList（）；
calls.addAll（列表）；
Collections.sort（调用，新的Comparator（）{
@凌驾
公共整数比较（调用o，调用t1）{
return（int）（o.getMS（）-t1.getMS（））；
}
});
}

这将根据
ms
.
您尝试了哪些示例？不清楚的是，比较器接口中有一个名为compare（objectO1，objectO2）的方法。你必须覆盖（实施）它。把你的排序逻辑放进去。。。逻辑很简单。。。如果O1。ms@TheLostMind+1工作正常..别忘了调用适配器。notifyDataSetChanged（）；这样变化就会立即发生。
public void loadList(ArrayList<Calls> list) {
    List<Calls> calls = new ArrayList<Calls>();
    calls.addAll( list );

    // Ascending Order
    Collections.sort(calls, new Comparator<Calls>() {

        @Override
        public int compare(Calls o1, Calls o2) {
            return (int)(o1.ms-o2.ms);
        }
    });
    // Descending Order
    Collections.sort(calls, new Comparator<Calls>() {

        @Override
        public int compare(Calls o1, Calls o2) {
            return (int)(o2.ms-o1.ms);
        }
    });
}

public void loadList(ArrayList<Calls> list) {
    List<Calls> calls = new ArrayList<Calls>();
    calls.addAll(list);
    Collections.sort(calls, new Comparator<Calls>() {
                @Override
                public int compare(Calls o, Calls t1) {
                    return (int) (o.getMS() - t1.getMS());
                }
            });
}