¿Cómo puedo ordenar una lista alfabéticamente?

Tengo un objeto List que contiene nombres de países. ¿Cómo puedo ordenar esta lista alfabéticamente?

Suponiendo que se trata de cadenas, utilice el método estático conveniente sort

  java.util.Collections.sort(listOfCountryNames) 

Solución con Collections.sort

Si se ve obligado a usar esa lista, o si su progtwig tiene una estructura como

  • Crear lista
  • Agregue algunos nombres de países
  • ordenarlos una vez
  • nunca más cambies esa lista

entonces la respuesta de Thilos será la mejor manera de hacerlo. Si lo combinas con el consejo de Tom Hawtin – tackline , obtienes:

 java.util.Collections.sort(listOfCountryNames, Collator.getInstance()); 

Solución con un TreeSet

Si puede decidir libremente, y si su aplicación puede ser más compleja, entonces puede cambiar su código para usar un TreeSet. Este tipo de colección clasifica tus entradas justo cuando se insertan. No es necesario llamar a sort ().

 Collection countryNames = new TreeSet(Collator.getInstance()); countryNames.add("UK"); countryNames.add("Germany"); countryNames.add("Australia"); // Tada... sorted. 

Nota al margen sobre por qué prefiero TreeSet

Esto tiene algunas ventajas sutiles, pero importantes:

  • Es simplemente más corto. Solo una línea más corta, sin embargo.
  • Nunca se preocupe, esta lista realmente está ordenada en este momento porque un TreeSet siempre está ordenado, sin importar lo que haga.
  • No puedes tener entradas duplicadas. Dependiendo de su situación, esto puede ser un problema o una estafa. Si necesita duplicados, quédese con su Lista.
  • Un progtwigdor experimentado observa TreeSet countyNames y lo sabe al instante: se trata de una colección ordenada de cadenas sin duplicados, y puedo estar seguro de que esto es cierto en todo momento . Tanta información en una breve statement.
  • El rendimiento real gana en algunos casos. Si usa una Lista e inserta valores muy a menudo, y la lista puede leerse entre esas inserciones, entonces debe ordenar la lista después de cada inserción. El conjunto hace lo mismo, pero lo hace mucho más rápido.

Usar la colección correcta para la tarea correcta es una clave para escribir código corto y libre de errores. No es tan demostrativo en este caso, porque solo guarda una línea. Pero he dejado de contar la frecuencia con la que veo a alguien usando una Lista cuando quieren asegurarse de que no haya duplicidades, y luego construyo esa funcionalidad por sí mismos. O aún peor, usando dos Listas cuando realmente necesita un Mapa.

No me malinterprete: el uso de Collections.sort no es un error o un defecto. Pero hay muchos casos cuando TreeSet es mucho más limpio.

Puede crear una nueva copia ordenada utilizando Java 8 Stream o Guava:

 // Java 8 version List sortedNames = names.stream().sorted().collect(Collectors.toList()); // Guava version List sortedNames = Ordering.natural().sortedCopy(names); 

Otra opción es clasificar in situ a través de la API de colecciones:

 Collections.sort(names); 

¡Mejor tarde que nunca! Aquí es cómo podemos hacerlo (solo con fines de aprendizaje) –

 import java.util.List; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; class SoftDrink { String name; String color; int volume; SoftDrink (String name, String color, int volume) { this.name = name; this.color = color; this.volume = volume; } } public class ListItemComparision { public static void main (String...arg) { List softDrinkList = new ArrayList() ; softDrinkList .add(new SoftDrink("Faygo", "ColorOne", 4)); softDrinkList .add(new SoftDrink("Fanta", "ColorTwo", 3)); softDrinkList .add(new SoftDrink("Frooti", "ColorThree", 2)); softDrinkList .add(new SoftDrink("Freshie", "ColorFour", 1)); Collections.sort(softDrinkList, new Comparator() { @Override public int compare(Object softDrinkOne, Object softDrinkTwo) { //use instanceof to verify the references are indeed of the type in question return ((SoftDrink)softDrinkOne).name .compareTo(((SoftDrink)softDrinkTwo).name); } }); for (SoftDrink sd : softDrinkList) { System.out.println(sd.name + " - " + sd.color + " - " + sd.volume); } Collections.sort(softDrinkList, new Comparator() { @Override public int compare(Object softDrinkOne, Object softDrinkTwo) { //comparision for primitive int uses compareTo of the wrapper Integer return(new Integer(((SoftDrink)softDrinkOne).volume)) .compareTo(((SoftDrink)softDrinkTwo).volume); } }); for (SoftDrink sd : softDrinkList) { System.out.println(sd.volume + " - " + sd.color + " - " + sd.name); } } } 

Usa los dos argumentos para Collections.sort . Usted querrá un Comparator adecuado que trate el caso apropiado (es decir, realiza el léxico, no el ordenamiento UTF16), como el que se puede obtener a través de java.text.Collator.getInstance .

A menos que esté ordenando cadenas en un inglés libre de acentos, es probable que desee utilizar un Collator . Clasificará correctamente las marcas diacríticas, puede ignorar el caso y otras cosas específicas del idioma:

 Collections.sort(countries, Collator.getInstance(new Locale(languageCode))); 

Puede establecer la fortaleza del clasificador , consulte el javadoc.

Aquí hay un ejemplo para eslovaco:

 List countries = Arrays.asList("Slovensko", "Švédsko", "Turecko"); Collections.sort(countries); System.out.println(countries); // outputs [Slovensko, Turecko, Švédsko] Collections.sort(countries, Collator.getInstance(new Locale("sk"))); System.out.println(countries); // outputs [Slovensko, Švédsko, Turecko] 

Esto es lo que estás buscando

 listOfCountryNames.sort(String::compareToIgnoreCase) 

Al usar Collections.sort() , podemos ordenar una lista.

 public class EmployeeList { public static void main(String[] args) { // TODO Auto-generated method stub List empNames= new ArrayList(); empNames.add("sudheer"); empNames.add("kumar"); empNames.add("surendra"); empNames.add("kb"); if(!empNames.isEmpty()){ for(String emp:empNames){ System.out.println(emp); } Collections.sort(empNames); System.out.println(empNames); } } } 

salida:

 sudheer kumar surendra kb [kb, kumar, sudheer, surendra] 

alfabeto descendente:

 List list; ... Collections.sort(list); Collections.reverse(list); 

En una línea, usando Java 8:

 list.sort(Comparator.naturalOrder()); 
 //Here is sorted List alphabetically with syncronized package com.mnas.technology.automation.utility; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; import java.util.List; import org.apache.log4j.Logger; /** * * @author manoj.kumar */ public class SynchronizedArrayList { static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName()); @SuppressWarnings("unchecked") public static void main(String[] args) { List synchronizedList = Collections.synchronizedList(new ArrayList()); synchronizedList.add(new Employee("Aditya")); synchronizedList.add(new Employee("Siddharth")); synchronizedList.add(new Employee("Manoj")); Collections.sort(synchronizedList, new Comparator() { public int compare(Object synchronizedListOne, Object synchronizedListTwo) { //use instanceof to verify the references are indeed of the type in question return ((Employee)synchronizedListOne).name .compareTo(((Employee)synchronizedListTwo).name); } }); /*for( Employee sd : synchronizedList) { log.info("Sorted Synchronized Array List..."+sd.name); }*/ // when iterating over a synchronized list, we need to synchronize access to the synchronized list synchronized (synchronizedList) { Iterator iterator = synchronizedList.iterator(); while (iterator.hasNext()) { log.info("Sorted Synchronized Array List Items: " + iterator.next().name); } } } } class Employee { String name; Employee (String name) { this.name = name; } } 

Lo mismo en JAVA 8: –

 //Assecnding order listOfCountryNames.stream().sorted().forEach((x) -> System.out.println(x)); //Decending order listOfCountryNames.stream().sorted((o1, o2) -> o2.compareTo(o1)).forEach((x) -> System.out.println(x)); 

Puedes intentar usar un método que hice.

String key : será el orden que desee y, en este caso, en orden alfabético. Solo pon “abc …”.

String list[] – la lista que desea ordenar usando la tecla.

int index – establecido como 0, configurará el desplazamiento para la tecla.

  public static String[] order(String key, String list[], int index) { ArrayList order_List = new ArrayList(); ArrayList temp_Order_List = null; char[] key_char = key.toCharArray(); for (int offset = 0; offset < key_char.length; offset++) { if (key_char.length >= offset + index) { String str = (index > 1 ? list[0].substring(0, index - 1) : "") + new String(key_char, offset, 1); for (int i = 0; i < list.length; i++) { temp_Order_List = new ArrayList(); for (int k = 0; k < list.length; k++) { if (!order_List.contains(list[k]) && !temp_Order_List.contains(list[k])) { if (list[k].equalsIgnoreCase(str)) order_List.add(list[k]); else if (list[k].toLowerCase().startsWith(str.toLowerCase())) { temp_Order_List.add(list[k]); } } } if (temp_Order_List.size() > 0) { if (temp_Order_List.size() > 1) { String[] add = order(key, temp_Order_List.toArray(new String[temp_Order_List .size()]), index + 1); for (String s : add) { order_List.add(s); } } else { order_List.add(temp_Order_List.get(0)); } } } } } return order_List.toArray(new String[order_List.size()]); }