Android-java自定义排序

我有一个字符串用户列表，上面有尼克的名字。我已经禁止了用户、普通用户和朋友用户

我想把我的朋友用户排在列表的顶部，把被禁止的用户排在列表的底部，我想给他们展示的是ASC风格

我该怎么做

因此，结构是：

  @Override
      public int compareTo(final myRow another) {

        final int BEFORE    =-1;
        final int EQUAL     = 0;
        final int AFTER     = 1;

        if (this==another) return EQUAL;

        if (sorttype==sort_type.SORT_ABC) {

            int rv      =0;
            int sorted  =row.toLowerCase().compareTo(another.getRow().toLowerCase());

            if (this.getUserType()==user_type.USER_TYPE_BANNED) rv=AFTER;
            if (this.getUserType()==user_type.USER_TYPE_NORMAL) rv=sorted;
            if (this.getUserType()==user_type.USER_TYPE_FRIEND) rv=BEFORE;

            Log.e("sorted", row+" "+this.getUserType()+" - "+rv+" ");

            return rv;

        } else if (sorttype==sort_type.SORT_LOGINTIME) {

            if (this.getUserType()==user_type.USER_TYPE_BANNED) {
                return AFTER;
            }
            if (this.getUserType()==user_type.USER_TYPE_NORMAL) return EQUAL;
            if (this.getUserType()==user_type.USER_TYPE_FRIEND) {
                //int sorted    =row.toLowerCase().compareTo(another.getRow().toLowerCase());
                return BEFORE;
            }

            //return 0;
        }

        return 0;

        //return row.toLowerCase().compareTo(another.getRow().toLowerCase());
      }

我明白了：

Abc  (friend)
abrt (friend)
dfgh (friend)

abdfg (normal user)
bnmm  (normal user)
wert  (normal user)

Andgh  (banned user)
Dfghhj (banned user)
Qwer   (banned user)

---

您的ABC排序逻辑不起作用。例如，如果传入两个

USER\u TYPE\u FRIEND

对象，无论它们各自的顺序如何，

compareTo

将始终返回

之前的

您需要通过首先比较usertype来实现这一点

如果它们相等，则可以将
行.compareTo（…）
表达式返回

如果不是，则只需根据逻辑中这些类型的“比较”方式（即friend您的代码看起来有点复杂。最简单的方法是从最高优先级字段开始，然后向下移动到其他字段。一个示例代码是：

06-19 14:43:46.586: ERROR/AndroidRuntime(23434): java.lang.IllegalArgumentException: Comparison method violates its general contract!

公共类成员实现可比较的{
静态枚举状态{
正常（1），朋友（2），禁止（3）；
私人最终int订单；
状态（国际订单）{
这个。顺序=顺序；
}
public int getOrder（）{
退回此订单；
}
};
私有最终字符串名；
私人最终地位；
公共成员（最终字符串名称、最终状态）{
this.name=名称；
这个状态=状态；
}
@凌驾
公共国际比较组织（成员o）{
如果（此状态等于（o状态））{
返回此.name.compareTo（o.name）；
}否则{
将此.status.compareTo返回（o.status）；
}
}
@凌驾
公共字符串toString（）{
返回“Member[name=“+name+”，status=“+status+”]”；
}
公共静态void main（字符串[]args）抛出可丢弃的{
成员[]成员={
新成员（“abrt”，身份。朋友），
新成员（“dfgh”，身份。朋友），
新成员（“abdf”，状态正常），
新成员（“wert”，状态正常），
新成员（“andgh”，状态。禁止），
新成员（“qwer”，状态。禁止）
};
List lst=Arrays.asList（成员）；
集合。排序（lst）；
系统输出打印项次（lst）；
}
}
现在我的代码：

public class Member implements Comparable<Member> {

    static enum Status {
        NORMAL(1), FRIEND(2), BANNED(3);

        private final int order;

        Status(int order) {
            this.order = order;
        }

        public int getOrder() {
            return this.order;
        }

    };

    private final String name;

    private final Status status;

    public Member(final String name, final Status status) {
        this.name = name;
        this.status = status;
    }

    @Override
    public int compareTo(Member o) {
        if (this.status.equals(o.status)) {
            return this.name.compareTo(o.name);
        } else {
            return this.status.compareTo(o.status);
        }
    }

    @Override
    public String toString() {
        return "Member [name=" + name + ", status=" + status + "]";
    }

    public static void main(String[] args) throws Throwable {
        Member[] members = {
                        new Member("abrt", Status.FRIEND),
                        new Member("dfgh", Status.FRIEND),
                        new Member("abdf", Status.NORMAL),
                        new Member("wert", Status.NORMAL),
                        new Member("andgh", Status.BANNED),
                        new Member("qwer", Status.BANNED)
        };
        List<Member> lst = Arrays.asList(members);
        Collections.sort(lst);
        System.out.println(lst);
    }


}


谢谢你，桑杰
 是包含此方法的类的名称
myRow
？不客气。：）顺便说一句，请遵循Java的做法，使用camelcase命名类/枚举/接口（即
UserType
而不是
user\u type
或
MyRow
而不是
MyRow
）。建议阅读：
  public enum user_type {USER_TYPE_FRIEND(1), USER_TYPE_NORMAL(2), USER_TYPE_BANNED(3);
      private final int order;
      user_type(int order) {
          this.order = order;
      }
      public int getOrder() {
          return this.order;
      }
  }

  @Override
  public int compareTo(final myRow another) {

    if (sorttype==sort_type.SORT_ABC) {
        if (this.getUserType().equals(another.getUserType())) {
            return this.getRow().toLowerCase().compareTo(another.getRow().toLowerCase());
        } else {
            return this.getUserType().compareTo(another.getUserType());
        }
    } 
    else {
        //LOGINTIME
        return this.getUserType().compareTo(another.getUserType());
    }
  }