Android-java-如何在对象内按特定值sorting对象列表
我试图通过在对象内的特定值的对象的数组列表sorting。 做这样的事情最好的办法是什么？ 我应该使用Collections.sort（）和某种比较器吗？
我试图sorting一个浮动值，他们在一个variables中的对象列表。
编辑：这是我到目前为止：
public class CustomComparator implements Comparator<Marker> { @Override public int compare(Mark o1, Mark o2) { return o1.getDistance().compareTo(o2.getDistance()); } } 错误状态：无法在基本typesdouble上调用compareTo（double）。
是否因为比较器不能返回某种types的东西？
如果您要查找的是默认sorting，则应该使用Comparable而不是Comparator。
看到这里，这可能会有一些帮助 – class级什么时候应该比较和/或比较？
尝试这个 –
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; } }
按照这个代码sorting任何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(obj2.empId); // To compare integer values // ## Descending order // return obj2.firstName.compareToIgnoreCase(obj1.firstName); // To compare string values // return Integer.valueOf(obj2.empId).compareTo(obj1.empId); // To compare integer values } });
我想这会帮助你更好
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()); } });
现在没有必要拳击（即不需要创buildOBJECT使用新的运算符使用valueOf与比较Collections.Sort .. insted）
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()); } });
“Android-java”在这里与“普通的java”没有任何区别，所以是的Collections.sort()将是一个很好的方法。
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());
可以使Comparator可以比较您的对象，或者如果它们是同一类的所有实例，则可以使该类实现为Comparable 。 然后你可以使用Collections.sort（）来进行实际的sorting。
你可以用这个比较两个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); } });
现在创build一个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; } }
这里contactsList是：
public static ArrayList<ContactsData> contactsList = new ArrayList<ContactsData>();
我有一个列表视图，它显示了我使用这个自定义比较器类来sorting客户端名称的所有客户端的信息。 他们除了英文字母之外还有一些额外的字母，我用这个setStrength（Collator.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);*/
型号类别：
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); }
现在sortingArrayList
Collections.sort(toDoList);
总结：它会按date对数据进行sorting
