Android-java- Comment trier une liste d'objets par une certaine valeur à l'intérieur de l'objet ?

Question

J'essaie de trier un tableau d'objets par une valeur particulière dans l'objet. Quelle serait la meilleure approche pour faire une telle chose. Devrais-je utiliser Collections.sort() avec une sorte de comparateur ?

J'essaie de trier une liste d'objets par une valeur flottante qu'ils détiennent dans une des variables.

EDIT : Voici ce que j'ai pour l'instant :

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

les états d'erreur : Impossible d'invoquer compareTo(double) sur le type primitif double.

Est-ce parce qu'un comparateur ne peut pas retourner autre chose qu'un certain type ?

Answer 1

Soit faire un Comparator qui peut comparer vos objets, ou s'ils sont tous des instances de la même classe, vous pouvez faire en sorte que cette classe implémente Comparable . Vous pouvez ensuite utiliser Collections.sort() pour effectuer le tri réel.

Answer 2

Classe de modèle :

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

Maintenant, définissez les données dans 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);
}

Trier maintenant ArrayList

Collections.sort(toDoList);

Résumé : il classe vos données par date

Answer 3

J'utilise ce code :

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

}) ;

Answer 4

J'ai une vue de liste qui montre les informations sur tous les clients. Je trie le nom des clients en utilisant cette classe de comparateur personnalisée. Ils ont des lettres supplémentaires en plus des lettres anglaises que je gère avec cette classe de comparateur personnalisée. que je gère avec ce 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);*/