wie man eine ArrayList in aufsteigender Reihenfolge mit Collections und Comparator sortiert

Question

Wie sortiert man ein ArrayList in aufsteigender Reihenfolge mit Comparator ? Ich weiß, wie man es in absteigender Reihenfolge mit sortieren:

Comparator mycomparator = Collections.reverseOrder();

dann

Collections.sort(myarrayList,mycomparator);

Ich möchte nur wissen, wie man es in aufsteigender Reihenfolge mit Collections und Komparator sortieren? Danke!

Answer 1

Ich sag's einfach mal so: Kannst du nicht einfach machen:

Collections.sort(myarrayList);

Es ist aber schon eine Weile her...

Answer 2

Verwenden Sie die Standardversion:

Collections.sort(myarrayList);

Dies erfordert natürlich, dass Ihre Elemente Comparable aber das gilt auch für die von Ihnen erwähnte Version.

BTW: Sie sollten Generics in Ihrem Code verwenden, auf diese Weise erhalten Sie Kompilierzeitfehler, wenn Ihre Klasse nicht Comparable implementiert. Und Kompilierzeitfehler sind viel besser als die Laufzeitfehler, die Sie sonst bekommen würden.

List<MyClass> list = new ArrayList<MyClass>();
// now fill up the list

// compile error here unless MyClass implements Comparable
Collections.sort(list);

Answer 3

Es gibt zwei Möglichkeiten, dies zu erreichen:

Collections.sort(myArray)

gegebene Elemente in myArray implementiert Comparable

Zweite

Collections.sort(myArray, new MyArrayElementComparator());

où MyArrayElementComparator es Comparator für Elemente innerhalb von myArray

Answer 4

Hier ein vollständiges Beispiel:

Angenommen, wir haben eine Personenklasse 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 **/
}

Jetzt erstellen wir einen Komparator:

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

Nehmen wir schließlich 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 **/
}

Jetzt versuchen wir dies:

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

Answer 5

Nach Wert sortieren

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