Tri des listes par ordre alphabétique (insensible à la casse)

J'ai un arraylist de chaîne namesqui contient des noms de personnes. Je veux trier l'arraylist par ordre alphabétique.

ArrayList<String> names = new ArrayList<String>();
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<names.size(); i++)
    System.out.println(names.get(i));

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

Athira
Karthika
..
..
ananya
bala
...

mais je ne veux pas le rendre sensible à la casse. Je veux le résultat comme:

ananya
Athira
bala

La coutume Comparatordevrait aider

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

Ou si vous utilisez Java 8:

list.sort(String::compareToIgnoreCase);

La chose la plus simple à faire est:

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

essayez ce code

Collections.sort(yourarraylist, 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;// where FBFriends_Obj is your object class
    FBFriends_Obj dd2 = (FBFriends_Obj)o2;
    return dd1.uname.compareToIgnoreCase(dd2.uname);//where uname is field name
}

}

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

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

        });

Vous devez utiliser un comparateur personnalisé qui utilisera compareToIgnoreCase, et non compareTo.

À partir de Java 8, vous pouvez utiliser Stream:

List<String> sorted = Arrays.asList(
                          names.stream().sorted(
                              (s1, s2) -> s1.compareToIgnoreCase(s2)
                          ).toArray(String[]::new)
                      );

Il obtient un flux à partir de cela ArrayList, puis il le trie (en ignorant le cas). Après cela, le flux est converti en un tableau qui est converti en ArrayList.

Si vous imprimez le résultat en utilisant:

System.out.println(sorted);

vous obtenez la sortie suivante:

[ananya, Athira, bala, jeena, Karthika, Neethu, Nithin, seetha, sudhin, Swetha, Tony, Vinod]

Malheureusement, toutes les réponses à ce jour ne prennent pas en compte ce qui "a"ne doit pas être considéré comme égal "A"au tri.

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

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

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

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

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

L'approche 2 aggrave les choses, car CASE_INSENSITIVE_ORDER considère "a"et est "A"égal (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 humble avis le seul moyen de le faire correctement, car elle considère "a"et "A"n'est pas égale, mais les met dans le bon ordre en fonction de la locale actuelle (ou de toute autre locale souhaitée).