Trier arraylist par ordre alphabétique (sans faire attention à la casse)

Question

J'ai une arraylist de chaînes de caractères names qui contient les noms des personnes. Je veux trier l'arraylist par ordre alphabétique.

ArrayList names = new ArrayList();
names.add("seetha");
names.add("sudhin");
names.add("Swetha");
names.add("Neethu");
names.add("ananya");
names.add("Athira");
names.add("bala");
names.add("Tony");
names.add("Karthika");
names.add("Nithin");
names.add("Vinod");
names.add("jeena");
Collections.sort(names);
for(int i=0; i

`J'ai essayé de trier la liste de la manière ci-dessus. Mais elle affiche le tableau trié comme suit :

Athira
Karthika
..
..
ananya
bala
...

Mais je ne veux pas que ce soit sensible à la casse. Je veux le résultat comme suit :

ananya
Athira
bala`

Answer 1

Un Comparator personnalisé devrait aider

Collections.sort(list, new Comparator() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareToIgnoreCase(s2);
    }
});

Ou si vous utilisez Java 8 :

list.sort(String::compareToIgnoreCase);

Answer 2

La chose la plus simple à faire est:

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

Answer 3

Essayez ce code

Collections.sort(votreArrayList, new SortBasedOnName());

import java.util.Comparator;
import com.RealHelp.objects.FBFriends_Obj;
import com.RealHelp.ui.importFBContacts;

public class SortBasedOnName implements Comparator
{
public int compare(Object o1, Object o2) 
{

    FBFriends_Obj dd1 = (FBFriends_Obj)o1;// où FBFriends_Obj est votre classe d'objet
    FBFriends_Obj dd2 = (FBFriends_Obj)o2;
    return dd1.uname.compareToIgnoreCase(dd2.uname);// où uname est le nom du champ
}

}

Answer 4

Sur la base des réponses mentionnées ci-dessus, j'ai réussi à comparer mes objets de classe personnalisés comme ceci :

ArrayList itemList = new ArrayList<>();
...
Collections.sort(itemList, new Comparator() {
            @Override
            public int compare(Item item, Item t1) {
                String s1 = item.getTitle();
                String s2 = t1.getTitle();
                return s1.compareToIgnoreCase(s2);
            }

        });

Answer 5

Malheureusement, toutes les réponses jusqu'à présent ne prennent pas en compte le fait que "a" ne doit pas être considéré comme égal à "A" en matière de tri.

String[] array = {"b", "A", "C", "B", "a"};

// Approche 1
Arrays.sort(array);
// array est [A, B, C, a, b]

// Approche 2
Arrays.sort(array, String.CASE_INSENSITIVE_ORDER);
// array est [A, a, b, B, C]

// Approche 3
Arrays.sort(array, java.text.Collator.getInstance());
// array est [a, A, b, B, C]

Dans l'approche 1, toutes les lettres minuscules sont considérées comme étant supérieures à toutes les lettres majuscules.

L'approche 2 aggrave les choses, car CASE_INSENSITIVE_ORDER considère "a" et "A" comme égaux (le résultat de la comparaison est 0). Cela rend le tri non déterministe.

L'approche 3 (en utilisant un java.text.Collator) est à mon avis la seule manière de le faire correctement, car elle considère "a" et "A" comme différents, mais les place dans le bon ordre selon l'actuel (ou tout autre) paramètre de Locale désiré.