gewusst wie: Sortieren einer ArrayList in aufsteigender Reihenfolge mithilfe von Sammlungen und Komparator

Gewusst wie: Sortieren einer ArrayList in aufsteigender Reihenfolge mit Comparator? Ich weiß, wie ich es Sortieren in absteigender Reihenfolge:

Comparator mycomparator = Collections.reverseOrder();

dann

Collections.sort(myarrayList,mycomparator);

möchte nur wissen, wie es in aufsteigender Reihenfolge sortiert mit Sammlungen und Komparator? Danke!

Hast du das forum durchsuchen? Wird diese Frage einmal pro Tag.

InformationsquelleAutor user1097097 | 2011-12-15

21

Nur werfen dies draußen...könnt Ihr nicht einfach tun:
```
Collections.sort(myarrayList);
```
Es ist eine Weile gewesen, obwohl...

danke, möchte nur wissen, ist es möglich, zu definieren, einen Komparator?

InformationsquelleAutor Cody S
9

Verwenden Sie die Standard-version:
```
Collections.sort(myarrayList);
```
Dies erfordert natürlich, dass Ihre Elemente implementieren Comparable, aber das gleiche gilt für die version, die Sie erwähnt.

BTW: sollten Sie Generika in Ihrem code, so erhalten Sie compile-Zeit Fehler, wenn Sie Ihre Klasse nicht implementieren Vergleichbar. Und compile-Zeit-Fehler sind viel besser als die runtime-Fehler erhalten Sie, sonst.
```
List<MyClass> list = new ArrayList<MyClass>();
//now fill up the list

//compile error here unless MyClass implements Comparable
Collections.sort(list); 
```
danke, möchte nur wissen, ist es möglich, zu definieren, einen Komparator?
ja, Sie können definieren und übergeben comparator Sortieren API
ja, Lesen Sie die Object Bestellung-tutorial, es erklärt Komparatoren
+1 für Generika und kompilieren Fehler ohne Vergleichbar 🙂

InformationsquelleAutor Sean Patrick Floyd
1

Zwei Möglichkeiten, dieses zu erhalten getan:
```
Collections.sort(myArray)
```
Elementen innerhalb myArray implementiert Vergleichbar

Zweiten
```
Collections.sort(myArray, new MyArrayElementComparator());
```
wo MyArrayElementComparator ist Comparator für Elemente innerhalb myArray

InformationsquelleAutor mprabhat

Hier ein vollständiges Beispiel :

Nehmen wir an, wir haben eine Klasse "Person" wie :

public class Person
{
    protected String fname;
    protected String lname;

    public Person()
    {

    }

    public Person(String fname, String lname)
    {
        this.fname = fname;
        this.lname = lname;
    }

    public boolean equals(Object objet)
    {
        if(objet instanceof Person)
        {
            Person p = (Person) objet;
            return (p.getFname().equals(this.fname)) && p.getLname().equals(this.lname));
        }
        else return super.equals(objet);
    }

    @Override
    public String toString()
    {
        return "Person(fname : " + getFname + ", lname : " + getLname + ")";
    }

    /** Getters and Setters **/
}

Nun erstellen wir eine comparator :

import java.util.Comparator;

public class ComparePerson implements Comparator<Person>
{
    @Override
    public int compare(Person p1, Person p2)
    {
        if(p1.getFname().equalsIgnoreCase(p2.getFname()))
        {
            return p1.getLname().compareTo(p2.getLname());
        }
        return p1.getFname().compareTo(p2.getFname());
    }
}

Schließlich nehmen wir an, wir haben eine Gruppe von Personen :

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Group
{
    protected List<Person> listPersons;

    public Group()
    {
        this.listPersons = new ArrayList<Person>();
    }

    public Group(List<Person> listPersons)
    {
        this.listPersons = listPersons;
    }

    public void order(boolean asc)
    {
        Comparator<Person> comp = asc ? new ComparePerson() : Collections.reverseOrder(new ComparePerson());
        Collections.sort(this.listPersons, comp);
    }

    public void display()
    {
        for(Person p : this.listPersons)
        {
            System.out.println(p);
        }
    }

    /** Getters and Setters **/
}

Nun versuchen wir dieses :

import java.util.ArrayList;
import java.util.List;

public class App
{
    public static void main(String[] args)
    {
        Group g = new Group();
        List listPersons = new ArrayList<Person>();
        g.setListPersons(listPersons);

        Person p;

        p = new Person("A", "B");
        listPersons.add(p);

        p = new Person("C", "D");
        listPersons.add(p);

        /** you can add Person as many as you want **/

        g.display();

        g.order(true);
        g.display();

        g.order(false);
        g.display();
    }
}

InformationsquelleAutor Djahid Bekka

Art Von Wert

  public Map sortByValue(Map map, final boolean ascending) {
            Map result = new LinkedHashMap();
            try {
                List list = new LinkedList(map.entrySet());

                Collections.sort(list, new Comparator() {
                    @Override
                    public int compare(Object object1, Object object2) {
                        if (ascending)
                            return ((Comparable) ((Map.Entry) (object1)).getValue())
                                    .compareTo(((Map.Entry) (object2)).getValue());
                        else
                            return ((Comparable) ((Map.Entry) (object2)).getValue())
                                    .compareTo(((Map.Entry) (object1)).getValue());

                    }
                });

                for (Iterator it = list.iterator(); it.hasNext();) {
                    Map.Entry entry = (Map.Entry) it.next();
                    result.put(entry.getKey(), entry.getValue());
                }

            } catch (Exception e) {
                Log.e("Error", e.getMessage());
            }

            return result;
        }

InformationsquelleAutor user1140237

Dies funktionieren könnte?

Comparator mycomparator = 
    Collections.reverseOrder(Collections.reverseOrder());

InformationsquelleAutor xofon

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.