Android-java-如何根据对象中的某个值对对象列表进行排序

我试图根据对象内部的特定值对对象的数组进行排序。做这件事的最好方法是什么。我是否应该将 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)。

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

237501 次浏览
小开

“ Android-java”在这里与“普通 java”没有任何不同，所以是的，Collections.sort()将是一个很好的方法。

小开

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

小开
最佳答案

如果您想要的是默认排序，那么应该使用 Compaable 而不是 Compaator。

看这里，这可能有些帮助-什么时候一个类应该是 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;
}
}
小开

我觉得这个会对你更有帮助

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());
}
});
小开

按照下面的代码对任何数组列表进行排序

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
}
});
小开 
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());
小开

我有一个列表视图，显示所有客户的信息 我正在使用这个自定义比较器类对客户端名称进行排序。 除了英文字母外，他们还有一些额外的字母 我正在使用这个 setStrong (Collator.CONDARY)进行管理

 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);*/
小开

可以使用以下方法比较两个 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;


}
}

这里的联系人列表是:

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

模型类: 

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);
}

现在排序数组列表

Collections.sort(toDoList);

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

小开

现在不需要装箱(也就是说不需要使用 new Operator use valueOf 和 compareTo of Collection 一起创建 OBJECT)。排序。.)

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());
}
});
小开

对科特林来说很简单！

listToBeSorted.sortBy { it.distance }

小开

对于 科特林，可以使用这个函数

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!!) }
}

在你的 activity或者 fragment调用它

sortList(list)
小开

人物模型类

 class Person {
int id;
String name;
String fatherName;


public Person(int id, String name, String fatherName) {
this.id = id;
this.name = name;
this.fatherName = fatherName;
}
        

}

分类

class SORT_BY_ID implements Comparator<Person> {
public int compare(Person a, Person b)
{
return a.id - b.id;
}
}

用法

 ArrayList<Person> personArrayList = new ArrayList<Person>();
personArrayList.add(new Person(111, "bb", "oakla"));
personArrayList.add(new Person(131, "aa", "fast"));
personArrayList.add(new Person(121, "cccc", "paokla"));


System.out.println("Before Sorted Array list of PErson");
for (int i=0; i<personArrayList.size(); i++)
System.out.println(personArrayList.get(i));


Collections.sort(personArrayList, new SORT_BY_ID());


System.out.println("After Sorted ");
for (int i=0; i<personArrayList.size(); i++)
System.out.println(personArrayList.get(i));
小开

我正在使用这个代码:

Collections.sort(groupMemberList, new Comparator<GroupMember>() {
@Override
public int compare(GroupMember o1, GroupMember o2) {
return Long.valueOf(o2.getStatus()).compareTo(Long.valueOf(o1.getStatus()));
}
@Override
public boolean equals(Object obj) {
return false;
}

});


提交答案