una - ordenar lista java 8




Cómo ordenar una Lista<Objeto> alfabéticamente usando el campo Nombre del objeto (10)

Tengo una Lista de objetos como List<Object> 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<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 ..?


Aquí hay una versión de la respuesta de Robert B que funciona para List<T> 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 <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;
}

Desde su código, parece que su Comparator ya 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 último comentario: no tiene sentido verificar el tamaño de la lista. Sort funcionará en una lista vacía.


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<String,YourClass>() {
  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 "programación funcional".

Copiado descaradamente de esta respuesta en mi propia pregunta.


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<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 la internacionalización, use 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());
        }
       });
   }

Puede usar sortThisBy() desde Eclipse Collections :

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

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

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

Nota: soy colaborador de las colecciones de Eclipse.


Si está utilizando una List<Object> 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<Object> en primer lugar si puede ayudarlo: mantenga sus objetos nombrados en una List<NamedObject>
  2. Copie los elementos List<Object> en una List<NamedObject> , 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<Object> () {
        int compare (final Object a, final Object b) {
                return ((NamedObject) a).getName().compareTo((NamedObject b).getName());
        }
}


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;

}

if(listAxu.size() > 0){
     Collections.sort(listAxu, new Comparator<Situacao>(){
        @Override
        public int compare(Situacao lhs, Situacao rhs) {            
            return lhs.getDescricao().compareTo(rhs.getDescricao());
        }
    });
 }

public class ObjectComparator implements Comparator<Object> {

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




list