Ordinamento della lista di array in ordine alfabetico (senza distinzione tra maiuscole e minuscole)

Ho un elenco di stringhe namesche contiene nomi di persone. Desidero ordinare l'elenco degli array in ordine alfabetico.

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

Ho provato a ordinare l'elenco nel modo sopra. Ma mostra l'array ordinato come:

Athira
Karthika
..
..
ananya
bala
...

ma non voglio che faccia distinzione tra maiuscole e minuscole. Voglio il risultato come:

ananya
Athira
bala

L'abitudine Comparatordovrebbe aiutare

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

O se stai usando Java 8:

list.sort(String::compareToIgnoreCase);

La cosa più semplice da fare è:

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

prova questo codice

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
}

}

Sulla base delle risposte sopra menzionate, sono riuscito a confrontare i miei oggetti di classe personalizzati in questo modo:

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

        });

È necessario utilizzare il comparatore personalizzato che utilizzerà compareToIgnoreCase, non compareTo.

A partire da Java 8 puoi utilizzare Stream:

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

Ottiene un flusso da quello ArrayList, quindi lo ordina (ignorando il caso). Successivamente, il flusso viene convertito in un array che viene convertito in un file ArrayList.

Se stampi il risultato usando:

System.out.println(sorted);

si ottiene il seguente output:

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

Purtroppo tutte le risposte fino ad ora non tengono conto di ciò che "a"non deve essere considerato uguale a "A"quando si parla di smistamento.

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]

Nell'approccio 1 qualsiasi lettera minuscola è considerata maggiore di qualsiasi lettera maiuscola.

L'approccio 2 peggiora le cose, poiché CASE_INSENSITIVE_ORDER considera "a"ed è "A"uguale (il risultato del confronto è 0). Ciò rende l'ordinamento non deterministico.

L'approccio 3 (utilizzando un java.text.Collator) è IMHO l'unico modo per farlo correttamente, poiché considera "a"e "A"non è uguale, ma li mette nell'ordine corretto in base alla Locale corrente (o qualsiasi altra desiderata).