Android-java- Come ordinare un elenco di oggetti con un determinato valore all'interno dell'oggetto

Question

Sto cercando di ordinare un arraylist di oggetti con un valore particolare all'interno dell'oggetto. Quale sarebbe l'approccio migliore per fare una cosa del genere. Dovrei usare Collections.sort() con qualche tipo di comparatore?

Sto cercando di ordinare un elenco di oggetti con un valore float che contengono in una delle variabili.

EDIT: Questo è quello che ho finora:

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

gli stati di errore: non può invocare compareTo (doppio) del tipo primitivo doppia.

È perché un comparatore non può restituire altro che un determinato tipo?

Answer 1

È necessario utilizzare Paragonabile anziché un comparatore se un ordinamento predefinito è quello che stai cercando.

vedere qui, questo può essere di qualche aiuto - When should a class be Comparable and/or Comparator?

Prova questo -

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

Answer 2

"Android-java" non è qui diverso da "normale java", quindi sì Collections.sort() sarebbe un buon approccio.

Answer 3

O effettuare uno Comparator che può confrontare i propri oggetti, o se sono tutte le istanze della stessa classe, è possibile rendere tale classe implementare Comparable. È quindi possibile utilizzare Collections.sort() per eseguire l'ordinamento effettivo.

Answer 4

Credo che questo vi aiuterà a meglio

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

Answer 5

Seguire questo codice per ordinare qualsiasi 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 
     } 
    }); 

Answer 6

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; 

Modo d'uso:

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

Answer 7

Ho un listview che mostra le informazioni sui tutti i clienti sto ordinamento dei clienti nome utilizzando questa classe di confronto personalizzato. Essi stanno avendo un certo lerret in più a parte le lettere inglese che sto gestione di questo 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);*/ 

Answer 8

È possibile confrontare due String utilizzando questo.

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

        } 

       }); 

E ora creare una classe 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; 

} 
} 

Qui contactsList è: Classe

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

Answer 9

Modello:

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

dati ora impostato in 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); 
} 

ora Ordina ArrayList

Collections.sort(toDoList); 

Sommario: Sarà ordinare i dati datewise

Answer 10

Ora non c'è bisogno di Boxing (vale a dire non c'è bisogno di creare OBJECT utilizzando il nuovo uso Operator valueOf invece con confronto di Collections.Sort ..)

1) Per ordine crescente

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

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

1) Per Deascending ordine

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

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