Cómo ordenar una Lista alfabéticamente usando el campo Nombre del objeto

Tengo una Lista de objetos como List p . Quiero ordenar esta lista alfabéticamente usando el campo Nombre del objeto. El objeto contiene 10 campos y el campo de nombre es uno de ellos.

 if (list.size() > 0) { Collections.sort(list, new Comparator() { @Override public int compare(final Object object1, final Object object2) { return String.compare(object1.getName(), object2.getName()); } } ); } 

Pero no hay nada como String.compare ..?

Desde su código, parece que su Comparator ya está parametrizado con Campaign . Esto solo funcionará con List . Además, el método que está buscando es compareTo .

 if (list.size() > 0) { Collections.sort(list, new Comparator() { @Override public int compare(final Campaign object1, final Campaign object2) { return object1.getName().compareTo(object2.getName()); } }); } 

O si está utilizando Java 1.8

 list .stream() .sorted((object1, object2) -> object1.getName().compareTo(object2.getName())); 

Un último comentario: no tiene sentido verificar el tamaño de la lista. Sort funcionará en una lista vacía.

La forma más correcta de ordenar cadenas alfabéticamente es usar Collator , debido a la internacionalización. Algunos idiomas tienen un orden diferente debido a algunos caracteres adicionales, etc.

  Collator collator = Collator.getInstance(Locale.US); if (!list.isEmpty()) { Collections.sort(list, new Comparator() { @Override public int compare(Campaign c1, Campaign c2) { //You should ensure that list doesn't contain null values! return collator.compare(c1.getName(), c2.getName()); } }); } 

Si no le importa la internacionalización, use string.compare(otherString) .

  if (!list.isEmpty()) { Collections.sort(list, new Comparator() { @Override public int compare(Campaign c1, Campaign c2) { //You should ensure that list doesn't contain null values! return c1.getName().compare(c2.getName()); } }); } 

Eche un vistazo a Collections.sort() y la interfaz Comparator .

La comparación de cadenas se puede hacer con object1.getName().compareTo(object2.getName()) o object2.getName().compareTo(object1.getName()) (dependiendo de la dirección de ordenamiento que desee).

Si desea que el tipo sea object1.getName().toUpperCase().compareTo(object2.getName().toUpperCase()) caso, haga object1.getName().toUpperCase().compareTo(object2.getName().toUpperCase()) .

 public class ObjectComparator implements Comparator { public int compare(Object obj1, Object obj2) { return obj1.getName().compareTo(obj2.getName()); } } 

Por favor reemplace el objeto con su clase que contiene el campo de nombre

Uso:

 ObjectComparator comparator = new ObjectComparator(); Collections.sort(list, comparator); 

algo como

  List theList = … ; Collections.sort (theList, new Comparator () { int compare (final FancyObject a, final FancyObject d) { return (a.getName().compareTo(d.getName())); }}); 

Aquí hay una versión de la respuesta de Robert B que funciona para List y ordenando por una propiedad de Cadena especificada del objeto utilizando Reflection y sin bibliotecas de terceros.

 /** * Sorts a List by the specified String property name of the object. * * @param list * @param propertyName */ public static  void sortList(List list, final String propertyName) { if (list.size() > 0) { Collections.sort(list, new Comparator() { @Override public int compare(final T object1, final T object2) { String property1 = (String)ReflectionUtils.getSpecifiedFieldValue (propertyName, object1); String property2 = (String)ReflectionUtils.getSpecifiedFieldValue (propertyName, object2); return property1.compareToIgnoreCase (property2); } }); } } public static Object getSpecifiedFieldValue (String property, Object obj) { Object result = null; try { Class< ?> objectClass = obj.getClass(); Field objectField = getDeclaredField(property, objectClass); if (objectField!=null) { objectField.setAccessible(true); result = objectField.get(obj); } } catch (Exception e) { } return result; } public static Field getDeclaredField(String fieldName, Class< ?> type) { Field result = null; try { result = type.getDeclaredField(fieldName); } catch (Exception e) { } if (result == null) { Class< ?> superclass = type.getSuperclass(); if (superclass != null && !superclass.getName().equals("java.lang.Object")) { return getDeclaredField(fieldName, type.getSuperclass()); } } return result; } 

Puede usar sortThisBy() desde Eclipse Collections :

 MutableList list = Lists.mutable.empty(); list.sortThisBy(Campaign::getName); 

Si no puede cambiar el tipo de lista de la List :

 List list = new ArrayList<>(); ListAdapter.adapt(list).sortThisBy(Campaign::getName); 

Nota: soy colaborador de las colecciones de Eclipse.

Si sus objetos tienen algún antecesor común [que sea T ], debe usar List lugar de List e implementar un Comparador para esta T, usando el campo de nombre.

Si no tiene un ancestro común, puede implementar un Competente y usar el reflection para extraer el nombre. Tenga en cuenta que es inseguro, no sugerido y tiene un mal rendimiento para usar el reflection, pero le permite acceder a un nombre de campo. sin saber nada sobre el tipo real del objeto [además del hecho de que tiene un campo con el nombre relevante]

En ambos casos, debe usar Collections.sort () para ordenar.

Esto supone una lista de YourClass lugar de Object , como se explica en amit .

Puedes usar este bit de la biblioteca de Google Guava:

 Collections.sort(list, Ordering.natural() .onResultOf(new Function() { public String call(YourClass o) { return o.getName(); })) .nullsLast(); 

Las otras respuestas que mencionan Comparator no son incorrectas, ya que Ordering implementa Comparator . Esta solución es, en mi opinión, un poco más fácil, aunque puede ser más difícil si eres un principiante y no estás acostumbrado a usar bibliotecas y / o “progtwigción funcional”.

Copiado descaradamente de esta respuesta en mi propia pregunta.

Usando una selección Ordenar

 for(int i = list.size() - 1; i > 0; i--){ int max = i for(int j = 0; j < i; j++){ if(list.get(j).getName().compareTo(list.get(j).getName()) > 0){ max= j; } } //make the swap Object temp = list.get(i); list.get(i) = list.get(max); list.get(max) = temp; } 

Si está utilizando una List para contener objetos de un subtipo que tiene un campo de nombre (llamemos al subtipo NamedObject ), deberá bajar los elementos de la lista para acceder al nombre. Tienes 3 opciones, la mejor de las cuales es la primera:

  1. No use List en primer lugar si puede ayudarlo: mantenga sus objetos nombrados en una List
  2. Copie los elementos List en una List , downcasting en el proceso, haga la ordenación, luego cópielos de nuevo
  3. Hacer downcasting en el Comparador

La opción 3 se vería así:

 Collections.sort(p, new Comparator () { int compare (final Object a, final Object b) { return ((NamedObject) a).getName().compareTo((NamedObject b).getName()); } } 
 if(listAxu.size() > 0){ Collections.sort(listAxu, new Comparator(){ @Override public int compare(Situacao lhs, Situacao rhs) { return lhs.getDescricao().compareTo(rhs.getDescricao()); } }); } 

Usando Java 8 Comparator.comparing :

 list.sort(Comparator.comparing(Campaign::getName)); 

Prueba esto:

 List< Object> myList = x.getName; myList.sort(Comparator.comparing(Object::getName));