Ordenar la lista de listas en orden alfabético (sin distinción entre mayúsculas y minúsculas)

Tengo una lista de cadenas namesque contiene nombres de personas. Quiero ordenar la lista de arrays en orden alfabético.

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

Traté de ordenar la lista de la manera anterior. Pero muestra la matriz ordenada como:

Athira
Karthika
..
..
ananya
bala
...

pero no quiero que sea sensible a mayúsculas y minúsculas. Quiero el resultado como:

ananya
Athira
bala

La costumbre Comparatordebería ayudar

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

O si está utilizando Java 8:

list.sort(String::compareToIgnoreCase);

Lo más simple es:

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

prueba este código

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
}

}

Basado en las respuestas mencionadas anteriormente, logré comparar mis objetos de clase personalizados de esta manera:

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

        });

Debe usar un comparador personalizado que usará compareToIgnoreCase, no compareTo.

A partir de Java 8 puede usar Stream:

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

Obtiene una secuencia de eso ArrayList, luego lo ordena (ignorando el caso). Después de eso, la secuencia se convierte en una matriz que se convierte en unArrayList .

Si imprime el resultado usando:

System.out.println(sorted);

obtienes el siguiente resultado:

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

Desafortunadamente, todas las respuestas hasta ahora no tienen en cuenta que "a"no deben considerarse iguales a "A"la hora de ordenar.

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 el enfoque 1, cualquier letra minúscula se considera mayor que cualquier letra mayúscula.

El enfoque 2 lo empeora, ya que CASE_INSENSITIVE_ORDER considera "a"e "A"igual (el resultado de la comparación es 0). Esto hace que la ordenación no sea determinista.

El Enfoque 3 (usando un java.text.Collator) es, en mi humilde opinión, la única forma de hacerlo correctamente, ya que lo considera "a"y "A"no es igual, pero los coloca en el orden correcto de acuerdo con la configuración regional actual (o cualquier otra deseada).