Come ordinare un elenco alfabeticamente utilizzando il campo Nome object

Ho una lista di oggetti come List p . Voglio ordinare questo elenco alfabeticamente usando il campo Nome object. L’object contiene 10 campi e il campo nome è uno di questi.

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

Ma non c’è niente come String.compare ..?

Dal tuo codice, sembra che il tuo Comparator sia già parametrizzato con Campaign . Funzionerà solo con l’ List . Inoltre, il metodo che stai cercando è 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 se stai usando Java 1.8

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

Un ultimo commento: non ha senso controllare la dimensione dell’elenco. L’ordinamento funzionerà su una lista vuota.

Il modo più corretto per ordinare le stringhe alfabeticamente è utilizzare Collator , a causa dell’internazionalizzazione. Alcune lingue hanno un ordine diverso a causa di pochi caratteri extra, ecc.

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

Se non ti interessa l’internazionalizzazione usa 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()); } }); } 

Dai un’occhiata a Collections.sort() e all’interfaccia di Comparator .

Il confronto delle stringhe può essere eseguito con object1.getName().compareTo(object2.getName()) o object2.getName().compareTo(object1.getName()) (a seconda della direzione di ordinamento desiderata).

Se si desidera che l’ordinamento sia indipendente dal caso, eseguire 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()); } } 

Si prega di sostituire object con la class che contiene il campo del nome

Uso:

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

qualcosa di simile a

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

Ecco una versione della risposta di Robert B che funziona per List e l’ordinamento in base a una specifica proprietà String dell’object utilizzando Reflection e nessuna libreria di terze parti

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

Puoi usare sortThisBy() da Eclipse Collections :

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

Se non è ansible modificare il tipo di elenco dall’elenco:

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

Nota: sono un collaboratore di Eclipse Collections.

Se i tuoi oggetti hanno un antenato comune [lascia che sia T ] dovresti usare List invece di List e implementare un Comparator per questo T, usando il campo name.

Se non si dispone di un antenato comune, è ansible implementare un Comperator e utilizzare reflection per estrarre il nome. Si noti che non è sicuro, non è interessato e soffre di prestazioni inadeguate per utilizzare il reflection, ma consente di accedere al nome di un campo senza sapere nulla sul tipo effettivo dell’object [oltre al fatto che ha un campo con il nome rilevante]

In entrambi i casi, è necessario utilizzare Collections.sort () per ordinare.

Questo presuppone un elenco di YourClass invece di Object , come spiegato da amit .

Puoi utilizzare questo bit dalla libreria Google Guava:

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

Le altre risposte che menzionano Comparator non sono errate, dal momento che Ordering implements Comparator . Questa soluzione è, a mio parere, un po ‘più semplice, anche se potrebbe essere più difficile se sei un principiante e non sei abituato a usare librerie e / o “programmazione funzionale”.

Copiato spudoratamente da questa risposta sulla mia stessa domanda.

Utilizzando una selezione Ordina

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

Se si utilizza un List per contenere oggetti di un sottotipo che ha un campo nome (consente di chiamare il sottotipo NamedObject ), sarà necessario downcast degli elementi dell’elenco per poter accedere al nome. Hai 3 opzioni, la migliore delle quali è la prima:

  1. Non usare un List in primo luogo se puoi aiutarlo – mantieni gli oggetti con nome in un List
  2. Copia gli elementi List in un List , downcasting nel processo, fai l’ordinamento, quindi copialo indietro
  3. Fai downcasting nel Comparator

L’opzione 3 sarebbe simile a questa:

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

Utilizzo di Java 8 Comparator.comparing :

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

Prova questo:

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