Cómo ordenar una lista <Objeto> alfabéticamente usando el campo de nombre de objeto

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

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

Pero no hay nada como String.compare ..?

A partir de su código, parece que Comparatorya está parametrizado con Campaign. Esto solo funcionará con List<Campaign>. Además, el método que está buscando es compareTo.

if (list.size() > 0) {
  Collections.sort(list, new Comparator<Campaign>() {
      @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 comentario final: no tiene sentido verificar el tamaño de la lista. Ordenar funcionará en una lista vacía.

La forma más correcta de ordenar alfabéticamente cadenas 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<Campaign>() {
        @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 el uso de la internacionalización string.compare(otherString).

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

Echar un vistazo a Collections.sort(), y elComparator interfaz.

La comparación de cadenas se puede realizar con object1.getName().compareTo(object2.getName())o object2.getName().compareTo(object1.getName())(según la dirección de clasificación que desee).

Si desea que el tipo sea independiente del caso, hágalo object1.getName().toUpperCase().compareTo(object2.getName().toUpperCase()).

Utilizando Java 8 Comparator.comparing :

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

public class ObjectComparator implements Comparator<Object> {

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

}

Reemplace el objeto con su clase que contiene el campo de nombre

Uso:

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

algo como

  List<FancyObject> theList = … ;
  Collections.sort (theList,
                    new Comparator<FancyObject> ()
                    { 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 List<T>y ordena por una propiedad String especificada del objeto usando Reflection y sin bibliotecas de terceros

/**
 * Sorts a List by the specified String property name of the object.
 * 
 * @param list
 * @param propertyName
 */
public static <T> void sortList(List<T> list, final String propertyName) {

    if (list.size() > 0) {
        Collections.sort(list, new Comparator<T>() {
            @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()de Eclipse Collections :

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

Si no puede cambiar el tipo de lista de List:

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

Nota: Soy colaborador de Eclipse Collections.

Prueba esto:

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

Si sus objetos tienen algún ancestro común [déjelo ser T], debe usar en List<T>lugar de List<Object>e implementar un Comparador para esta T, usando el campo de nombre.

Si no tiene un ancestro común, puede implementar un Comperator y usar la reflexión para extraer el nombre.Tenga en cuenta que no es seguro, no se sugiere y tiene un mal rendimiento para usar la reflexión, 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.

Encontré otra forma de escribir.

if(listAxu.size() > 0){
    Collections.sort(listAxu, Comparator.comparing(IdentityNamed::getDescricao));
}

Esto supone una lista de en YourClasslugar de Object, como explica amit .

Puede usar este bit de la biblioteca de Google Guava:

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

Las otras respuestas que mencionan Comparatorno son incorrectas, ya que Orderingimplementa 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 "programación funcional".

Copiado descaradamente de esta respuesta a 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 List<Object>para contener objetos de un subtipo que tiene un campo de nombre (llamemos al subtipo NamedObject), necesitará abatir los elementos de la lista para acceder al nombre. Tienes 3 opciones, la mejor de las cuales es la primera:

1. List<Object>En primer lugar, no use un si puede evitarlo; mantenga los objetos con nombre en unList<NamedObject>
2. Copie sus List<Object>elementos en un List<NamedObject>, reduciendo en el proceso, haga la clasificación y luego cópielos de nuevo
3. Hacer el downcasting en el comparador

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

Collections.sort(p, new Comparator<Object> () {
        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<Situacao>(){
        @Override
        public int compare(Situacao lhs, Situacao rhs) {            
            return lhs.getDescricao().compareTo(rhs.getDescricao());
        }
    });
 }

La respuesta de @ Victor funcionó para mí y volver a publicarla aquí en Kotlin en caso de que sea útil para otra persona que usa Android.

if (list!!.isNotEmpty()) {
   Collections.sort(
     list,
     Comparator { c1, c2 -> //You should ensure that list doesn't contain null values!
     c1.name!!.compareTo(c2.name!!)
   })
}