So sortieren Sie eine Liste & lt; Objekt & gt; alphabetisch mit dem Objektnamenfeld

Die richtige Art und Weise, alphabetisch zu Sortieren strings ist die Verwendung Collator, weil der Internationalisierung. Einige Sprachen haben unterschiedliche um durch wenige zusätzliche Zeichen, 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());
        }
       });
   }

Wenn Sie kümmern sich nicht um die Internationalisierung verwenden 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());
        }
       });
   }

InformationsquelleAutor der Antwort viktor

public class ObjectComparator implements Comparator<Object> {

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

}

Bitte ersetzen Sie das Objekt mit der Klasse enthält Feld name

Verwendung:

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

InformationsquelleAutor der Antwort Jan Vorcak

Hier ist eine version von Robert B ' s Antwort, das funktioniert für List<T> und Sortierung nach einer angegebenen Zeichenfolge-Eigenschaft des Objekts mit der Spiegelung und keine 3rd-party-Bibliotheken

/**
 * 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;
}

InformationsquelleAutor der Antwort che javara

Wenn Ihr Objekte hat einige gemeinsame Ahnen [lassen Sie es T] die Sie verwenden sollten List<T> statt List<Object> und Umsetzung einer Komparator für dieses T mit dem Feld name.

Wenn Sie nicht einen gemeinsamen Vorfahren haben, implementieren Sie einen Comperator, und verwenden Sie Reflexion zum extrahieren der Namen, Beachten Sie, dass es unsicher ist, unsuggested, und leidet unter schlechten Leistung reflektion verwenden, aber es ermöglicht Ihnen den Zugriff auf ein Feld name, ohne etwas über die tatsächliche Typ des Objekts [neben der Tatsache, dass es hat ein Feld mit dem entsprechenden Namen]

In beiden Fällen sollten Sie Sammlungen.sort() zu Sortieren.

InformationsquelleAutor der Antwort amit

Durch Auswahl Sortieren

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;

}

InformationsquelleAutor der Antwort Shizumaru18

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

InformationsquelleAutor der Antwort George Freire

Versuchen Sie dies:

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

InformationsquelleAutor der Antwort Alper Karaağaçlı