Android-java-如何按对象内的某个值对对象列表进行排序


112

我试图按对象内的特定值对对象的数组列表进行排序。什么是做这种事情的最佳方法。我应该将Collections.sort()与某种比较器一起使用吗?

我试图用一个变量中包含的浮点值对对象列表进行排序。

编辑:这是我到目前为止:

public class CustomComparator implements Comparator<Marker> {
    @Override
    public int compare(Mark o1, Mark o2) {
        return o1.getDistance().compareTo(o2.getDistance());
    }
}

错误状态:无法在原始类型double上调用compareTo(double)。

是因为比较器不能返回某种类型以外的任何东西吗?


2
“我应该将Collections.sort()与某种比较器一起使用吗?”是的,听起来像是个好主意
Kennet

我不知道这是否重要,但是列表中的对象数将高达80。这就是为什么我对使用比较器感到困惑,因为那是一种方法,因为它只能一次比较两个值。
詹姆斯·安德烈斯基斯

这就是排序的方式。首先将一个项目添加到列表中。当添加下一个时;应该在列表中的当前值之前还是之后。在添加第三项时,将其与列表中的第一项进行比较,如果在此之后,则与下一项进行比较。等等。
Kennet

Answers:


98

如果您要查找默认排序,则应使用Comparable而不是Comparator。

看到这里,这可能会有帮助- 类何时应该是Comparable和/或Comparator?

试试这个 -

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestSort {

    public static void main(String args[]){

        ToSort toSort1 = new ToSort(new Float(3), "3");
        ToSort toSort2 = new ToSort(new Float(6), "6");
        ToSort toSort3 = new ToSort(new Float(9), "9");
        ToSort toSort4 = new ToSort(new Float(1), "1");
        ToSort toSort5 = new ToSort(new Float(5), "5");
        ToSort toSort6 = new ToSort(new Float(0), "0");
        ToSort toSort7 = new ToSort(new Float(3), "3");
        ToSort toSort8 = new ToSort(new Float(-3), "-3");

        List<ToSort> sortList = new ArrayList<ToSort>();
        sortList.add(toSort1);
        sortList.add(toSort2);
        sortList.add(toSort3);
        sortList.add(toSort4);
        sortList.add(toSort5);
        sortList.add(toSort6);
        sortList.add(toSort7);
        sortList.add(toSort8);

        Collections.sort(sortList);

        for(ToSort toSort : sortList){
            System.out.println(toSort.toString());
        }
    }

}

public class ToSort implements Comparable<ToSort> {

    private Float val;
    private String id;

    public ToSort(Float val, String id){
        this.val = val;
        this.id = id;
    }

    @Override
    public int compareTo(ToSort f) {

        if (val.floatValue() > f.val.floatValue()) {
            return 1;
        }
        else if (val.floatValue() <  f.val.floatValue()) {
            return -1;
        }
        else {
            return 0;
        }

    }

    @Override
    public String toString(){
        return this.id;
    }
}

嘿,谢谢你的链接:)我从一种语言来回切换到另一种语言,所以我总是缺少一些东西:p你知道这是怎么回事...所有交易的杰克,但
无所不包的

365

按照此代码对任何ArrayList进行排序

Collections.sort(myList, new Comparator<EmployeeClass>(){
    public int compare(EmployeeClass obj1, EmployeeClass obj2) {
        // ## Ascending order
        return obj1.firstName.compareToIgnoreCase(obj2.firstName); // To compare string values
        // return Integer.valueOf(obj1.empId).compareTo(Integer.valueOf(obj2.empId)); // To compare integer values

        // ## Descending order
        // return obj2.firstName.compareToIgnoreCase(obj1.firstName); // To compare string values
        // return Integer.valueOf(obj2.empId).compareTo(Integer.valueOf(obj1.empId)); // To compare integer values
        }
    });

16
这应该是最佳答案!
约翰·史密斯

3
简单而又很好的答案,荣誉兄弟:)
Sadashiv 2015年

1
简单又小..谢谢!
16:32遇见Vora

1
这看起来真的很干净。谢谢。一加提供提示。
阿努拉格

2
仅适用于API 24及更高版本的工作
Themelis

42

我认为这会更好地帮助您

Person p = new Person("Bruce", "Willis");
Person p1  = new Person("Tom", "Hanks");
Person p2 = new Person("Nicolas", "Cage");
Person p3 = new Person("John", "Travolta");

ArrayList<Person> list = new ArrayList<Person>();
list.add(p);
list.add(p1);
list.add(p2);
list.add(p3);

Collections.sort(list, new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        Person p1 = (Person) o1;
        Person p2 = (Person) o2;
        return p1.getFirstName().compareToIgnoreCase(p2.getFirstName());
    }
});

24

现在无需装箱(即无需创建 OBJECT使用使用Operators的valueOf插入到具有Collections.Sort ..

1)升序

Collections.sort(temp, new Comparator<XYZBean>() 
{
     @Override
     public int compare(XYZBean lhs, XYZBean rhs) {

       return Integer.valueOf(lhs.getDistance()).compareTo(rhs.getDistance());
      }
 });

1)升序

Collections.sort(temp, new Comparator<XYZBean>() 
{
     @Override
     public int compare(XYZBean lhs, XYZBean rhs) {

       return Integer.valueOf(rhs.getDistance()).compareTo(lhs.getDistance());
      }
 });

2

这里的“ Android-java”与“普通的java”没有什么不同,所以Collections.sort()可以。


1
但是如何使它按对象内的值排序。那就是我坚持的。
James andresakis'2

2
public class DateComparator implements Comparator<Marker> {
    @Override
    public int compare(Mark lhs, Mark rhs) {
        Double distance = Double.valueOf(lhs.getDistance());
        Double distance1 = Double.valueOf(rhs.getDistance());
        if (distance.compareTo(distance1) < 0) {
            return -1;
        } else if (distance.compareTo(distance1) > 0) {
            return 1;
        } else {
            return 0;
        }
    }
}

ArrayList(Marker) arraylist;

如何使用:

Collections.sort(arraylist, new DateComparator());

2

您可以使用此方法比较两个String。

Collections.sort(contactsList, new Comparator<ContactsData>() {

                    @Override
                    public int compare(ContactsData lhs, ContactsData rhs) {

                        char l = Character.toUpperCase(lhs.name.charAt(0));

                        if (l < 'A' || l > 'Z')

                            l += 'Z';

                        char r = Character.toUpperCase(rhs.name.charAt(0));

                        if (r < 'A' || r > 'Z')

                            r += 'Z';

                        String s1 = l + lhs.name.substring(1);

                        String s2 = r + rhs.name.substring(1);

                        return s1.compareTo(s2);

                    }

                });

现在创建一个ContactData类。

public class ContactsData {

public String name;
public String id;
public String email;
public String avatar; 
public String connection_type;
public String thumb;
public String small;
public String first_name;
public String last_name;
public String no_of_user;
public int grpIndex;

public ContactsData(String name, String id, String email, String avatar, String connection_type)
{
    this.name = name;
    this.id = id;
    this.email = email;
    this.avatar = avatar;
    this.connection_type = connection_type;

}
}

这里的contactList是:

public static ArrayList<ContactsData> contactsList = new ArrayList<ContactsData>();

1

创建一个Comparator可以比较您的对象的对象,或者如果它们都是同一类的所有实例,则可以使该类实现Comparable。然后,您可以使用Collections.sort()进行实际排序。


我继续在类中实现Comparable,但是创建了一种方法,当我需要对列表进行排序时,可以在列表上调用sort,但是如何在对象中使用值对它进行排序呢?
James andresakis'2

compareTo()-方法是你做比较。稍作谷歌搜索就如何使用它给出了一些详细的示例,这是其中之一:javadeveloper.co.in/java-example/java-comparable-example.html
Jave

我设置了与示例类似的方法,但是出现错误,指出我不能在强制转换双精度上使用compareTo。似乎出于任何原因,我在做什么都不喜欢。无法在原始类型double上调用compareTo(double)。病态在上面添加我的代码以显示我的意思
James andresakis 2012年

1

对于Kotlin,您可以使用此功能

fun sortList(list: List<YourCustomPOJOClass?>) {

    //descending
    Collections.sort(
        list
    ) { o1, o2 -> Integer.valueOf(o1!!.intValueXYZ!!).compareTo(o2!!.intValueXYZ!!) }

//    //ascending
//    Collections.sort(
//        list
//    ) { o1, o2 -> Integer.valueOf(o2!!.intValueXYZ!!).compareTo(o1!!.intValueXYZ!!) }
}

而只是把它在你的activityfragment通过

sortList(list)

0

我有一个列表视图,其中显示了有关所有正在使用此自定义比较器类对客户端名称进行排序的所有客户端的信息。除了英文字母,我正在使用setStrength(Collat​​or.SECONDARY)进行管理,除了英文字母外,他们还有一些额外的提示

 public class CustomNameComparator implements Comparator<ClientInfo> {
        @Override

    public int compare(ClientInfo o1, ClientInfo o2) { 

        Locale locale=Locale.getDefault();
        Collator collator = Collator.getInstance(locale);
        collator.setStrength(Collator.SECONDARY);
        return collator.compare(o1.title, o2.title);

    }
}


PRIMARY strength: Typically, this is used to denote differences between base characters (for example, "a" < "b"). It is the strongest difference. For example, dictionaries are divided into different sections by base character. 
SECONDARY strength: Accents in the characters are considered secondary differences (for example, "as" < "às" < "at"). Other differences between letters can also be considered secondary differences, depending on the language. A secondary difference is ignored when there is a primary difference anywhere in the strings. 
TERTIARY strength: Upper and lower case differences in characters are distinguished at tertiary strength (for example, "ao" < "Ao" < "aò"). In addition, a variant of a letter differs from the base form on the tertiary strength (such as "A" and "Ⓐ"). Another example is the difference between large and small Kana. A tertiary difference is ignored when there is a primary or secondary difference anywhere in the strings. 
IDENTICAL strength: When all other strengths are equal, the IDENTICAL strength is used as a tiebreaker. The Unicode code point values of the NFD form of each string are compared, just in case there is no difference. For example, Hebrew cantellation marks are only distinguished at this strength. This strength should be used sparingly, as only code point value differences between two strings are an extremely rare occurrence. Using this strength substantially decreases the performance for both comparison and collation key generation APIs. This strength also increases the size of the collation key. 

**Here is a another way to make a rule base sorting if u need it just sharing**

/*      String rules="< å,Å< ä,Ä< a,A< b,B< c,C< d,D< é< e,E< f,F< g,G< h,H< ï< i,I"+"< j,J< k,K< l,L< m,M< n,N< ö,Ö< o,O< p,P< q,Q< r,R"+"< s,S< t,T< ü< u,U< v,V< w,W< x,X< y,Y< z,Z";
        RuleBasedCollator rbc = null;
        try {
            rbc = new RuleBasedCollator(rules);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        String myTitles[]={o1.title,o2.title};
        Collections.sort(Arrays.asList(myTitles), rbc);*/

0

型号类别:

public class ToDoModel implements Comparable<ToDoModel> {
    private String id;
    private Date taskDate;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Date getTaskDate() {
        return taskDate;
    }

    public void setTaskDate(Date taskDate) {
        this.taskDate = taskDate;
    }

    @Override
    public int compareTo(ToDoModel another) {
        return getTaskDate().compareTo(another.getTaskDate());  
    }
}

现在在ArrayList中设置数据

for (int i = 0; i < your_array_length; i++) {
    ToDoModel tm = new ToDoModel();
    tm.setId(your_id);
    tm.setTaskDate(your_date);
    mArrayList.add(tm);
}

现在对ArrayList进行排序

Collections.sort(toDoList);

摘要:它将按日期对数据进行排序


By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.