как отсортировать Arraylist в порядке возрастания, используя Коллекции и компараторы

Question

У меня есть arraylist, как использовать Comparator для сортировки в порядке возрастания? Я знаю, как сортировать его в порядке убывания с помощью:

Comparator mycomparator = Collections.reverseOrder(); 

затем

Collections.sort(myarrayList,mycomparator); 

просто хочу знать, как сортировать его в порядке возрастания с использованием коллекций и компаратор? Благодаря!

Answer 1

Используйте версию по умолчанию:

Collections.sort(myarrayList); 

Конечно, это требует, чтобы ваши элементы реализации Comparable, но то же самое относится и к версии, которую вы упомянули.

BTW: вы должны использовать генерические коды в своем коде, таким образом вы получите ошибки времени компиляции, если ваш класс не реализует Comparable. И ошибки времени компиляции намного лучше, чем ошибки времени выполнения, которые вы получите в противном случае.

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

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

Answer 2

Просто бросали это там ... Ты не можешь просто сделать:

Collections.sort(myarrayList); 

Это было некоторое время, хотя ...

Answer 3

Два пути, чтобы получить это сделано:

Collections.sort(myArray) 

данные элементы внутри объектов myArray Сопоставимые

Второй

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

где MyArrayElementComparator является Comparator для элементов внутри MyArray

Answer 4

Вот полный пример:

Пусть у нас есть класс Person, как:

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

Теперь мы создаем компаратор:

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

Пусть, наконец, у нас есть группа людей:

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

Сейчас мы пытаемся это:

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

Сортировать по значению

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

Answer 6

Это может сработать?

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