Comment faire pour trier par ordre alphabétique tout en ignorant la casse?

Voici un simple exemple java de la meilleure façon de le faire:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Sorter {
String fruits[] = new String[7];
List<String> lst;
Sorter() {
lst = new ArrayList<String>();
//initialise UNSORTED array
fruits[0] = "Melon"; fruits[1] = "apricot"; fruits[2] = "peach";
fruits[3] = "mango"; fruits[4] = "Apple";   fruits[5] = "pineapple";
fruits[6] = "banana";
}
public static void main(String[] args) {
Sorter srt = new Sorter();
srt.anyOldUnstaticMethod();
}
public void anyOldUnstaticMethod() {
Collections.addAll(lst, fruits);
System.out.println("Initial List");
for (String s : lst)
System.out.println(s);
Collections.sort(lst);
System.out.println("\nSorted List");
for (String s : lst)
System.out.println(s);
Collections.sort(lst, new SortIgnoreCase());
System.out.println("\nSorted Ignoring Case List");
for (String s : lst)
System.out.println(s);
}
public class SortIgnoreCase implements Comparator<Object> {
public int compare(Object o1, Object o2) {
String s1 = (String) o1;
String s2 = (String) o2;
return s1.toLowerCase().compareTo(s2.toLowerCase());
}
}
}

Il est très sait pas ce que vous essayez de faire, mais vous pouvez trier une liste comme ceci:

List<String> fruits = new ArrayList<String>(7);
fruits.add("Pineapple");
fruits.add("apple");
fruits.add("apricot");
fruits.add("Banana");
fruits.add("mango");
fruits.add("melon");        
fruits.add("peach");
System.out.println("Unsorted: " + fruits);
Collections.sort(fruits, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {              
return o1.compareToIgnoreCase(o2);
}
});
System.out.println("Sorted: " + fruits);

Je ne peux pas croire que personne n'a fait référence à la Collateur. Presque toutes ces réponses ne fonctionne que pour la langue anglaise.

Vous devriez toujours utiliser un Collateur de pour dictionnaire de tri.

Pour la casse collateur de la recherche de la langue anglaise, vous effectuez les opérations suivantes:

Collator usCollator = Collator.getInstance(Locale.US);
usCollator.setStrength(Collator.PRIMARY);
Collections.sort(listToSort, usCollator);

Passer java.text.Collator.getInstance() à Collections.sort méthode ; il va trier par ordre Alphabétique tout en ignorant la casse.

        ArrayList<String> myArray = new ArrayList<String>();
myArray.add("zzz");
myArray.add("xxx");
myArray.add("Aaa");
myArray.add("bb");
myArray.add("BB");
Collections.sort(myArray,Collator.getInstance());

Depuis Java 8, vous pouvez trier en utilisant l'API de Flux:

List<String> fruits = Arrays.asList("apple", "Apricot", "banana");
List<String> sortedFruit = fruits.stream()
.sorted(String.CASE_INSENSITIVE_ORDER)
.collect(Collectors.toList())

La différence avec Collections.sort est que cela retourne une nouvelle liste et de ne pas modifier l'existant.

Exemple à l'aide de Collections et ArrayList:

Développer un stagiaire statique de la classe comme dans l'exemple "CompareStrings".

Appeler le stagiaire statique de la classe dans la méthode main.

Facile à comprendre et fonctionne très bien!

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class MainClass {
public static void main(String[] args) {
ArrayList<String> myArray = new ArrayList<String>();
myArray.add("zzz");
myArray.add("xxx");
myArray.add("Aaa");
myArray.add("bb");
myArray.add("BB");
Collections.sort(myArray, new MainClass.CompareStrings());
for(String s : myArray) {
System.out.println(s);
}
}
public static class CompareStrings implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
return s1.compareToIgnoreCase(s2);
}
}
}

Vous pouvez appeler directement la valeur par défaut tri méthode sur la liste comme ceci:

myList.sort(String.CASE_INSENSITIVE_ORDER); //reads as the problem statement and cleaner

ou:

myList.sort(String::compareToIgnoreCase);  //reads as the problem statement and cleaner