web-dev-qa-db-fra.com

Liste de tri par ordre alphabétique (insensible à la casse)

J'ai une chaîne de caractères names qui contient les noms de personnes. Je veux trier la liste en 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:

Athira
Karthika
..
..
ananya
bala
...

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

ananya
Athira
bala
javasortingarraylist
113
andro-girl

Personnalisé Comparator devrait 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);
315
denis.solonenko

La chose la plus simple à faire est de:

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
188
djunod

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
}

}
29
hacker

Sur la base des réponses susmentionnées, j'ai réussi à comparer mes objets de classe personnalisés comme suit:

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);
            }

        });
10
Usman

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

4
Vladimir Ivanov

À 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 de cette ArrayList, puis le trie (en ignorant le cas). Après cela, le flux est converti en un tableau qui est converti en un 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]
2
ROMANIA_engineer

Malheureusement, toutes les réponses à ce jour ne tiennent pas compte du fait que "a" ne doit pas être considéré comme égal à "A" en ce qui concerne le 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]

En approche 1, toutes les lettres minuscules sont considérées plus grandes que les majuscules.

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

L’approche 3 (à l’aide de Java.text.Collator) est le seul moyen de le faire correctement à mon humble avis, car elle considère que "a"et "A" ne sont pas égaux, mais les place dans le bon ordre en fonction du toute autre région souhaitée).

0
Lars Gendner