web-dev-qa-db-fra.com

Tri d'une liste d'objets dans un ordre de tri personnalisé

Je souhaite implémenter une fonctionnalité de tri pour mon application de carnet d'adresses.

Je veux trier un ArrayList<Contact> contactArray. Contact est une classe qui contient quatre champs: nom, numéro de domicile, numéro de téléphone portable et adresse. Je veux trier sur name.

Comment puis-je écrire une fonction de tri personnalisée pour le faire?

javasortingcollectionsarraylist
108
Sameera0

Voici un tutoriel sur la commande d'objets:

Bien que je vais donner quelques exemples, je recommanderais de le lire quand même.

Il existe différentes façons de trier une ArrayList. Si vous voulez définir un natural (valeur par défaut) ordering, vous devez laisser Contact mettre en œuvre Comparable . En supposant que vous souhaitiez trier par défaut sur name, faites (les vérifications nulles étant omises pour plus de simplicité):

public class Contact implements Comparable<Contact> {

    private String name;
    private String phone;
    private Address address;

    public int compareTo(Contact other) {
        return name.compareTo(other.name);
    }

    // Add/generate getters/setters and other boilerplate.
}

pour que tu puisses faire

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

Collections.sort(contacts);

Si vous souhaitez définir un ordre contrôlable externe (qui remplace l'ordre naturel), vous devez créer un Comparator :

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

// Now sort by address instead of name (default).
Collections.sort(contacts, new Comparator<Contact>() {
    public int compare(Contact one, Contact other) {
        return one.getAddress().compareTo(other.getAddress());
    }
});

Vous pouvez même définir les Comparators dans la Contact afin de pouvoir les réutiliser au lieu de les recréer à chaque fois:

public class Contact {

    private String name;
    private String phone;
    private Address address;

    // ...

    public static Comparator<Contact> COMPARE_BY_PHONE = new Comparator<Contact>() {
        public int compare(Contact one, Contact other) {
            return one.phone.compareTo(other.phone);
        }
    };

    public static Comparator<Contact> COMPARE_BY_ADDRESS = new Comparator<Contact>() {
        public int compare(Contact one, Contact other) {
            return one.address.compareTo(other.address);
        }
    };

}

qui peut être utilisé comme suit:

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

// Sort by address.
Collections.sort(contacts, Contact.COMPARE_BY_ADDRESS);

// Sort later by phone.
Collections.sort(contacts, Contact.COMPARE_BY_PHONE);

Et, pour couronner le tout, vous pouvez envisager d’utiliser un comparateur javabéen générique:

public class BeanComparator implements Comparator<Object> {

    private String getter;

    public BeanComparator(String field) {
        this.getter = "get" + field.substring(0, 1).toUpperCase() + field.substring(1);
    }

    public int compare(Object o1, Object o2) {
        try {
            if (o1 != null && o2 != null) {
                o1 = o1.getClass().getMethod(getter, new Class[0]).invoke(o1, new Object[0]);
                o2 = o2.getClass().getMethod(getter, new Class[0]).invoke(o2, new Object[0]);
            }
        } catch (Exception e) {
            // If this exception occurs, then it is usually a fault of the developer.
            throw new RuntimeException("Cannot compare " + o1 + " with " + o2 + " on " + getter, e);
        }

        return (o1 == null) ? -1 : ((o2 == null) ? 1 : ((Comparable<Object>) o1).compareTo(o2));
    }

}

que vous pouvez utiliser comme suit:

// Sort on "phone" field of the Contact bean.
Collections.sort(contacts, new BeanComparator("phone"));

(comme vous le voyez dans le code, éventuellement des champs nuls sont déjà couverts pour éviter les NPE lors du tri)}

260
BalusC

En plus de ce qui a déjà été posté, sachez que depuis Java 8, nous pouvons raccourcir notre code et l'écrire comme ceci:

Collection.sort(yourList, Comparator.comparing(YourClass::getFieldToSortOn));

ou depuis que List a maintenant la méthode sort 

yourList.sort(Comparator.comparing(YourClass::getFieldToSortOn));

Explication:

Depuis Java 8, les interfaces fonctionnelles (interfaces avec une seule méthode abstraite - elles peuvent avoir plus de méthodes par défaut ou statiques) peuvent être facilement implémentées en utilisant:

Puisque Comparator<T> n'a qu'une seule méthode abstraite int compare(T o1, T o2), c'est une interface fonctionnelle.

Donc au lieu de (exemple de @BalusCrépondre )

Collections.sort(contacts, new Comparator<Contact>() {
    public int compare(Contact one, Contact other) {
        return one.getAddress().compareTo(other.getAddress());
    }
});

nous pouvons réduire ce code à:

Collections.sort(contacts, (Contact one, Contact other) -> {
     return one.getAddress().compareTo(other.getAddress());
});

Nous pouvons simplifier ce (ou n'importe quel) lambda en sautant 

  • types d'arguments (Java les déduira en fonction de la signature de la méthode) 
  • ou {return ... }

Donc au lieu de 

(Contact one, Contact other) -> {
     return one.getAddress().compareTo(other.getAddress();
}

nous pouvons écrire

(one, other) -> one.getAddress().compareTo(other.getAddress())

De plus, Comparator dispose également de méthodes statiques telles que comparing(FunctionToComparableValue) ou comparing(FunctionToValue, ValueComparator), que nous pourrions utiliser pour créer facilement des comparateurs devant comparer certaines valeurs spécifiques d'objets. 

En d'autres termes, nous pouvons réécrire le code ci-dessus en tant que

Collections.sort(contacts, Comparator.comparing(Contact::getAddress)); 
//assuming that Address implements Comparable (provides default order).
24
Pshemo

Cette page vous indique tout ce que vous devez savoir sur le tri des collections, telles que ArrayList.

Fondamentalement, vous devez

  • faites en sorte que votre classe Contact implémente l'interface Comparable de
    • créer une méthode public int compareTo(Contact anotherContact) en son sein.
  • Cela fait, vous pouvez simplement appeler Collections.sort(myContactList);,
    • où myContactList est ArrayList<Contact> (ou toute autre collection de Contact).

Il existe également un autre moyen, qui consiste à créer une classe de comparaison, et vous pouvez également en savoir plus à partir de la page liée.

Exemple:

public class Contact implements Comparable<Contact> {

    ....

    //return -1 for less than, 0 for equals, and 1 for more than
    public compareTo(Contact anotherContact) {
        int result = 0;
        result = getName().compareTo(anotherContact.getName());
        if (result != 0)
        {
            return result;
        }
        result = getNunmber().compareTo(anotherContact.getNumber());
        if (result != 0)
        {
            return result;
        }
        ...
    }
}
8
bguiz

BalusC et bguiz ont déjà donné des réponses très complètes sur l'utilisation des comparateurs intégrés de Java.

Je veux juste ajouter que google-collections a un Ordering class qui est plus "puissant" que les comparateurs standard . Vous pouvez faire des choses cool telles que composer des commandes, les inverser, en fonction du résultat d'une fonction pour vos objets ...

Ici est un article de blog qui mentionne certains de ses avantages.

5
Etienne Neveu

Vous devez faire en sorte que vos classes Contact implémentent Comparable , puis implémentez la méthode compareTo(Contact). De cette façon, Collections.sort pourra les trier pour vous. Selon la page à laquelle je suis lié, compareTo 'renvoie un entier négatif, zéro ou un entier positif, cet objet étant inférieur, égal ou supérieur à l'objet spécifié.

Par exemple, si vous voulez trier par nom (A à Z), votre classe ressemblerait à ceci:

public class Contact implements Comparable<Contact> {

    private String name;

    // all the other attributes and methods

    public compareTo(Contact other) {
        return this.name.compareTo(other.name);
    }
}
4
Kaleb Brasee

En utilisant lambdaj vous pouvez trier une collection de vos contacts (par exemple, par leur nom) comme suit

sort(contacts, on(Contact.class).getName());

ou par leur adresse:

sort(contacts, on(Contacts.class).getAddress());

etc. Plus généralement, il offre un accès DSL pour accéder à vos collections et les manipuler de différentes manières, comme filtrer ou regrouper vos contacts en fonction de certaines conditions, agréger certaines de leurs valeurs de propriété, etc.

3
Mario Fusco

Je l’ai fait de la manière suivante ... nombre et nom sont deux noms. Je dois trier le nom. Si un changement survient dans le nom de l'ordre arraliste, le numéro de la liste change également l'ordre.

public void sortval(){

        String tempname="",tempnum="";

         if (name.size()>1) // check if the number of orders is larger than 1
            {
                for (int x=0; x<name.size(); x++) // bubble sort outer loop
                {
                    for (int i=0; i < name.size()-x-1; i++) {
                        if (name.get(i).compareTo(name.get(i+1)) > 0)
                        {

                            tempname = name.get(i);

                            tempnum=number.get(i);


                           name.set(i,name.get(i+1) );
                           name.set(i+1, tempname);

                            number.set(i,number.get(i+1) );
                            number.set(i+1, tempnum);


                        }
                    }
                }
            }



}
0
sarath

utilisez cette méthode:

private ArrayList<myClass> sortList(ArrayList<myClass> list) {
    if (list != null && list.size() > 1) {
        Collections.sort(list, new Comparator<myClass>() {
            public int compare(myClass o1, myClass o2) {
                if (o1.getsortnumber() == o2.getsortnumber()) return 0;
                return o1.getsortnumber() < o2.getsortnumber() ? 1 : -1;
            }
        });
    }
    return list;
}

`

et utiliser: mySortedlist = sortList(myList);Pas besoin d'implémenter un comparateur dans votre classe . Si vous voulez un échange d'ordre inversé 1 et -1

0
Bruno Mulas

Collections.sort est une bonne implémentation. Si vous n'avez pas implémenté le comparable pour Contact, vous devrez passer un Implémentation du comparateur

À noter:

L'algorithme de tri est un mergesort modifié (dans lequel la fusion est omise si l'élément le plus élevé dans la sous-liste basse est inférieur à l'élément le plus bas dans la sous-liste haute). Cet algorithme offre des performances garanties de n log (n). La liste spécifiée doit être modifiable, mais ne doit pas nécessairement être redimensionnable. Cette implémentation vide la liste spécifiée dans un tableau, trie le tableau et effectue une itération sur la liste en réinitialisant chaque élément à partir de la position correspondante dans le tableau. Cela évite les performances n2 log (n) qui résulteraient d'une tentative de tri d'une liste liée sur place. 

Le type de fusion est probablement meilleur que la plupart des algorithmes de recherche que vous pouvez faire.

0
Joshua