descending - sort arraylist java




Ordina lista array di oggetti personalizzati per proprietà (16)

JAVA 8 espressione lambda

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

O

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)

Ho letto sull'ordinamento di ArrayList usando un comparatore, ma in tutti gli esempi le persone hanno usato compareTo che secondo alcune ricerche è un metodo per le stringhe.

Volevo ordinare una lista di oggetti personalizzati con una delle loro proprietà: un oggetto Date ( getStartDay() ). Normalmente li confronto per item1.getStartDate().before(item2.getStartDate()) quindi mi chiedevo se potevo scrivere qualcosa del tipo:

public class CustomComparator {
    public boolean compare(Object object1, Object object2) {
        return object1.getStartDate().before(object2.getStartDate());
    }
}

public class RandomName {
    ...
    Collections.sort(Database.arrayList, new CustomComparator);
    ...
}

Con Java 8 puoi utilizzare un riferimento al metodo per il tuo comparatore:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));

Da Java 8 poi non è necessario utilizzare Collections.sort() direttamente. List interfaccia di List ha un metodo sort() predefinito:

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());}); 

Vedi http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html .


Dato che Date implementa Comparable , ha un metodo compareTo proprio come fa String .

Quindi il tuo Comparator personalizzato potrebbe assomigliare a questo:

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

Il metodo compare() deve restituire un int , quindi non è possibile restituire direttamente un valore boolean come avevate pianificato in ogni caso.

Il tuo codice di smistamento sarebbe proprio come hai scritto tu:

Collections.sort(Database.arrayList, new CustomComparator());

Un modo leggermente più breve per scrivere tutto questo, se non hai bisogno di riutilizzare il tuo comparatore, è di scriverlo come una classe anonima incorporata:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

Dal momento che java-8

È ora possibile scrivere l'ultimo esempio in un formato più breve utilizzando un'espressione lambda per il Comparator :

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

E List ha un metodo di sort(Comparator) , quindi puoi abbreviare ulteriormente questo aspetto:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Questo è un idioma così comune che esiste un metodo integrato per generare un Comparator per una classe con una chiave Comparable :

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

Tutte queste sono forme equivalenti.


Il modo più semplice con JAVA 8 è per l'ordinamento alfabetico inglese

Implementazione di classe

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

Ordinare

  Collections.sort(Your List);

Se vuoi ordinare un alfabeto che contiene caratteri non inglesi puoi usare Locale ... Sotto il codice usa l'ordinamento dei caratteri turchi ...

Implementazione di classe

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));



   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

Ordinare

Collections.sort(your array list,new NewspaperClass());

Java 8 Lambda accorcia il tipo.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));

Le classi che hanno un ordinamento naturale (un numero di classe, ad esempio) dovrebbero implementare l'interfaccia Comparable, mentre le classi che non hanno un ordinamento naturale (una classe Chair, ad esempio) devono essere fornite con un comparatore (o un comparatore anonimo classe).

Due esempi:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Uso:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});

Nel 2016, il forum Java di Stoccarda in Germania, puoi dare un'occhiata a questa presentation .

Solo poche diapositive usano la lingua tedesca, il 99% del contenuto è il codice sorgente Java "basato su inglese"; piace

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

dove OurCustomComparator utilizza metodi predefiniti (e altre idee interessanti). Come mostrato, portando a un codice molto conciso per scegliere un metodo getter per l'ordinamento; e super semplice concatenamento (o inversione) dei criteri di ordinamento.

Se ti trovi in ​​java8, trovi molto materiale lì per iniziare.


Per Java 8:

Collections.sort(list, comparing(ClassName::getName));

o

Collections.sort(list, comparing(ClassName::getName).reversed());

Un altro modo è

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));

Per ordinare un ArrayList è possibile utilizzare il seguente frammento di codice:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});

Preferisco questo processo:

public class SortUtil
{    
    public static <T> List<T> sort(List<T> list, String sortByProperty)
    {
            Collections.sort(list, new BeanComparator(sortByProperty));
            return list;
    }
}

List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");

Se la lista degli oggetti ha una proprietà chiamata startDate , si chiami a utilizzarla ripetutamente. Puoi anche concatenarli startDate.time .

Ciò richiede che il tuo oggetto sia Comparable che significa che hai bisogno di compareTo , equals e hashCode .

Sì, potrebbe essere più veloce ... Ma ora non è necessario creare un nuovo comparatore per ogni tipo di ordinamento. Se è possibile risparmiare su tempo di sviluppo e rinunciare al runtime, si potrebbe andare con questo.


Puoi provare Guava Ordering :

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);

Questo frammento di codice potrebbe essere utile. Se vuoi ordinare un oggetto nel mio caso, voglio ordinare per VolumeName:

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

Questo funziona. Lo uso nel mio jsp.


Sì, è possibile, ad esempio, in questa risposta che IndexValue per la proprietà v della classe IndexValue

    // Sorting by property v using a custom comparator.
    Arrays.sort( array, new Comparator<IndexValue>(){
        public int compare( IndexValue a, IndexValue b ){
            return a.v - b.v;
        }
    });

Se noti qui sto creando una classe interna anonima (che è Java per le chiusure) e la passiamo direttamente al metodo di sort della classe Arrays

Il tuo oggetto può anche implementare Comparable (questo è ciò che String e la maggior parte delle librerie core di Java fanno) ma che definirebbe il "naturale ordinamento" della classe stessa, e non ti permetterà di collegarne di nuovi.


la tua classe customComparator deve implementare java.util.Comparator per poter essere utilizzata. deve anche oltre confrontare () AND equals ()

compare () deve rispondere alla domanda: l'oggetto 1 è minore di, uguale o maggiore dell'oggetto 2?

documenti completi: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html


Puoi ordinare usando java 8

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));




comparator