web-dev-qa-db-fra.com

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

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

javalistsortingcollectionsalphabetical
164
Lennie

En supposant qu'il s'agisse de chaînes, utilisez la méthode statique pratique sort …

 Java.util.Collections.sort(listOfCountryNames)
197
Thilo

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 des noms de pays
  • les trier une fois
  • ne changez plus jamais cette liste

thilos répondra alors comme le meilleur moyen de le faire. Si vous le combinez avec les conseils de Tom Hawtin - tackline, vous obtenez:

Java.util.Collections.sort(listOfCountryNames, Collator.getInstance());

Solution avec un TreeSet

Si vous êtes libre de décider et que votre application risque de devenir plus complexe, vous pouvez modifier votre code pour utiliser plutôt un TreeSet. Ce type de collection trie vos entrées juste au moment où elles sont insérées. Pas besoin d'appeler sort ().

Collection<String> countryNames = 
    new TreeSet<String>(Collator.getInstance());
countryNames.add("UK");
countryNames.add("Germany");
countryNames.add("Australia");
// Tada... sorted.

Note latérale sur la raison pour laquelle je préfère le TreeSet

Cela présente des avantages subtils mais importants:

  • C'est simplement plus court. Une seule ligne plus courte, cependant.
  • Ne vous inquiétez jamais pour cette liste est-elle vraiment triée en ce moment car un TreeSet est toujours trié, peu importe ce que vous faites.
  • Vous ne pouvez pas avoir des entrées en double. Selon votre situation, cela peut être un avantage ou un inconvénient. Si vous avez besoin de doublons, respectez votre liste.
  • Un programmeur expérimenté regarde TreeSet<String> countyNames et sait instantanément: c'est une collection triée de chaînes sans doublons, et je peux être sûr que cela est vrai à chaque instant. Autant d'informations dans une courte déclaration.
  • La performance réelle gagne 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 une clé pour écrire du code court et sans bug. Ce n'est pas aussi démonstratif dans ce cas, car vous ne sauvegardez qu'une ligne. Mais j'ai arrêté de compter combien de fois je vois quelqu'un qui utilise une liste quand il veut s'assurer qu'il n'y a pas de doublons, puis j'ai créé cette fonctionnalité lui-même. Ou pire encore, utilisez deux listes lorsque vous avez vraiment besoin d'une carte.

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

137
Lena Schimmel

Vous pouvez créer une nouvelle copie triée à l’aide de Java 8 Stream ou Guava:

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

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

Collections.sort(names);
26
Vitalii Fedorenko

Mieux vaut tard que jamais! Voici comment nous pouvons le faire (à des fins d'apprentissage uniquement) -

import Java.util.List;
import Java.util.ArrayList;
import Java.util.Collections;
import Java.util.Comparator;

class SoftDrink {
    String name;
    String color;
    int volume; 

    SoftDrink (String name, String color, int volume) {
        this.name = name;
        this.color = color;
        this.volume = volume;
    }
}

public class ListItemComparision {
    public static void main (String...arg) {
        List<SoftDrink> softDrinkList = new ArrayList<SoftDrink>() ;
        softDrinkList .add(new SoftDrink("Faygo", "ColorOne", 4));
        softDrinkList .add(new SoftDrink("Fanta",  "ColorTwo", 3));
        softDrinkList .add(new SoftDrink("Frooti", "ColorThree", 2));       
        softDrinkList .add(new SoftDrink("Freshie", "ColorFour", 1));

        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((SoftDrink)softDrinkOne).name
                        .compareTo(((SoftDrink)softDrinkTwo).name);
            }
        }); 
        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.name + " - " + sd.color + " - " + sd.volume);
        }
        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //comparision for primitive int uses compareTo of the wrapper Integer
                return(new Integer(((SoftDrink)softDrinkOne).volume))
                        .compareTo(((SoftDrink)softDrinkTwo).volume);
            }
        });

        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.volume + " - " + sd.color + " - " + sd.name);
        }   
    }
}
24
Tirath

Utilisez les deux arguments de Collections.sort. Vous voudrez un Comparator approprié qui traite la casse de manière appropriée (c'est-à-dire un ordre lexical et non UTF16), tel que celui pouvant être obtenu via Java.text.Collator.getInstance.

9
Tom Hawtin - tackline

À moins que vous ne triiez les chaînes dans un anglais sans accent, vous souhaiterez probablement utiliser un Collator. Il va trier correctement les marques diacritiques, peut ignorer les cas et d’autres choses spécifiques à la langue:

Collections.sort(countries, Collator.getInstance(new Locale(languageCode)));

Vous pouvez définir le force du collateur , voir le javadoc.

Voici un exemple pour le slovaque:

List<String> countries = Arrays.asList("Slovensko", "Švédsko", "Turecko");

Collections.sort(countries);
System.out.println(countries); // outputs [Slovensko, Turecko, Švédsko]

Collections.sort(countries, Collator.getInstance(new Locale("sk")));
System.out.println(countries); // outputs [Slovensko, Švédsko, Turecko]
7
Oliv

Sur une ligne, en utilisant Java 8:

list.sort(Comparator.naturalOrder());
7
Victor Petit

Voici ce que vous recherchez

listOfCountryNames.sort(String::compareToIgnoreCase)
5
prashant

En utilisant Collections.sort(), nous pouvons trier une liste.

public class EmployeeList {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<String> empNames= new ArrayList<String>();

        empNames.add("sudheer");
        empNames.add("kumar");
        empNames.add("surendra");
        empNames.add("kb");

        if(!empNames.isEmpty()){

            for(String emp:empNames){

                System.out.println(emp);
            }

            Collections.sort(empNames);

            System.out.println(empNames);
        }
    }
}

sortie:

sudheer
kumar
surendra
kb
[kb, kumar, sudheer, surendra]
4
ASR

alphabet décroissant:

List<String> list;
...
Collections.sort(list);
Collections.reverse(list);
2
norbDEV
//Here is sorted List alphabetically with syncronized
package com.mnas.technology.automation.utility;
import Java.util.ArrayList;
import Java.util.Collections;
import Java.util.Comparator;
import Java.util.Iterator;
import Java.util.List;

import org.Apache.log4j.Logger;
/**
* 
* @author manoj.kumar
*/
public class SynchronizedArrayList {
static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());
@SuppressWarnings("unchecked")
public static void main(String[] args) {

List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
synchronizedList.add(new Employee("Aditya"));
synchronizedList.add(new Employee("Siddharth"));
synchronizedList.add(new Employee("Manoj"));
Collections.sort(synchronizedList, new Comparator() {
public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
//use instanceof to verify the references are indeed of the type in question
return ((Employee)synchronizedListOne).name
.compareTo(((Employee)synchronizedListTwo).name);
}
}); 
/*for( Employee sd : synchronizedList) {
log.info("Sorted Synchronized Array List..."+sd.name);
}*/

// when iterating over a synchronized list, we need to synchronize access to the synchronized list
synchronized (synchronizedList) {
Iterator<Employee> iterator = synchronizedList.iterator();
while (iterator.hasNext()) {
log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
}
}

}
}
class Employee {
String name;
Employee (String name) {
this.name = name;

}
}
0
user4423251

Idem dans Java 8: -

//Assecnding order
        listOfCountryNames.stream().sorted().forEach((x) -> System.out.println(x));

//Decending order
        listOfCountryNames.stream().sorted((o1, o2) -> o2.compareTo(o1)).forEach((x) -> System.out.println(x));
0
Vijay Gupta