Comment puis-je trier une liste par ordre alphabétique ?

Question

J'ai un objet List qui contient des noms de pays. Comment puis-je trier cette liste par ordre alphabétique?

Answer 1

En supposant que ce sont des chaînes de caractères, utilisez la méthode statique pratique sort:

Collections.sort(listOfCountryNames)

Answer 2

Solution avec Collections.sort

Si vous êtes obligé d'utiliser cette Liste, ou si votre programme a une structure comme

• Créer une Liste
• Ajouter quelques noms de pays
• les trier une fois
• ne jamais changer cette liste

alors la réponse de Thilos sera le meilleur moyen pour le faire. Si vous combinez cela avec les conseils de Tom Hawtin - tackline, vous obtenez :

java.util.Collections.sort(listeDeNomsDePays, Collator.getInstance());

Solution avec un TreeSet

Si vous êtes libre de décider, et si votre application pourrait devenir plus complexe, alors vous pouvez modifier votre code pour utiliser un TreeSet à la place. Ce type de collection trie vos entrées au moment de leur insertion. Pas besoin d'appeler sort().

Collection nomsDePays = 
    new TreeSet(Collator.getInstance());
nomsDePays.add("UK");
nomsDePays.add("Germany");
nomsDePays.add("Australia");
// Tada... trié.

Note sur pourquoi je préfère le TreeSet

Cela a quelques avantages subtils mais importants :

• C'est simplement plus court. D'une seule ligne cependant.
• Ne vous inquiétez jamais de est-ce que cette liste est vraiment triée actuellement parce qu'un TreeSet est toujours trié, peu importe ce que vous faites.
• Vous ne pouvez pas avoir d'entrées en double. Selon votre situation, cela peut être un avantage ou un inconvénient. Si vous avez besoin de doublons, restez sur votre Liste.
• Un programmeur expérimenté regarde TreeSet nomsDePays et sait immédiatement : il s'agit d'une collection de Strings triée sans doublons, et je peux être sûr que c'est vrai à chaque moment. Tant d'informations dans une courte déclaration.
• Véritable gain de performance dans certains cas. Si vous utilisez une Liste, et insérez des valeurs très souvent, et que la liste peut être lue entre ces insertions, vous devez trier la liste après chaque insertion. ​​L'ensemble fait la même chose, mais le fait beaucoup plus rapidement.

Utiliser la bonne collection pour la bonne tâche est la clé pour écrire un code court et sans bugs. Ce n'est pas aussi démonstratif dans ce cas, car vous ne sauvez qu'une ligne. Mais j'ai arrêté de compter combien de fois je vois quelqu'un utiliser une Liste quand il veut garantir qu'il n'y a pas de doublons, et ensuite construire cette fonctionnalité eux-mêmes. Ou pire encore, utiliser deux Listes quand vous avez vraiment besoin d'une Map.

Ne vous méprenez pas : utiliser Collections.sort n'est pas une erreur ou un défaut. Mais il y a de nombreux cas où le TreeSet est beaucoup plus propre.

Answer 3

Vous pouvez créer une nouvelle copie triée en utilisant Java 8 Stream ou Guava :

// Version Java 8
List sortedNames = names.stream().sorted().collect(Collectors.toList());
// Version Guava
List sortedNames = Ordering.natural().sortedCopy(names); 

Une autre option est de trier sur place via l'API Collections :

Collections.sort(names);

Answer 4

Utilisez la forme à deux arguments de Collections.sort. Vous voudrez un Comparator approprié qui traite les cas de manière appropriée (c'est-à-dire qu'il effectue un classement lexical, et non UTF16), tel que celui qui est récupérable via java.text.Collator.getInstance.

Answer 5

Vous pouvez essayer d'utiliser une méthode que j'ai créée.

String clé - sera l'ordre que vous désirez et dans ce cas alphabétiquement. Il suffit de mettre "abc...".

String liste[] - la liste que vous voulez mettre en ordre en utilisant la clé.

int index - défini à 0, définira le décalage pour la clé.

    public static String[] ordre(String clé, String liste[], int index) {
    ArrayList liste_ordonnée = new ArrayList();
    ArrayList liste_temporaire = null;
    char[] clé_char = clé.toCharArray();
    for (int décalage = 0; décalage < clé_char.length; décalage++) {
        if (clé_char.length >= décalage + index) {
            String str = (index > 1 ? liste[0].substring(0, index - 1) : "")
                    + new String(clé_char, décalage, 1);
            for (int i = 0; i < liste.length; i++) {
                liste_temporaire = new ArrayList();
                for (int k = 0; k < liste.length; k++) {
                    if (!liste_ordonnée.contains(liste[k])
                            && !liste_temporaire.contains(liste[k])) {
                        if (liste[k].equalsIgnoreCase(str))
                            liste_ordonnée.add(liste[k]);
                        else if (liste[k].toLowerCase().startsWith(str.toLowerCase())) {
                            liste_temporaire.add(liste[k]);

                        }
                    }
                }
                if (liste_temporaire.size() > 0) {
                    if (liste_temporaire.size() > 1) {
                        String[] ajouter = ordre(clé,
                                liste_temporaire.toArray(new String[liste_temporaire
                                        .size()]), index + 1);
                        for (String s : ajouter) {
                            liste_ordonnée.add(s);
                        }
                    } else {
                        liste_ordonnée.add(liste_temporaire.get(0));
                    }
                }
            }
        }
    }
    return liste_ordonnée.toArray(new String[liste_ordonnée.size()]);
}