如何使用集合和比較器以升序對Arraylist進行排序

Question

我有一個arraylist，如何使用Comparator將其按升序排序？我知道如何給它的降序排序使用：

Comparator mycomparator = Collections.reverseOrder(); 

然後

Collections.sort(myarrayList,mycomparator); 

只是想知道如何將它使用類別和比較升序排序？謝謝！

Answer 1

使用默認版本：

Collections.sort(myarrayList); 

當然，這要求你的元素實現Comparable，但你提到的版本也是如此。

順便說一句：你應該在你的代碼中使用泛型，這樣你會得到編譯時錯誤，如果你的類沒有實現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());