如何使用集合和比较器以升序对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());