Java 如何使用集合和比较器按升序对ArrayList排序

如何使用

比较器对
数组列表
进行升序排序？我知道如何使用以下命令按降序排序：

Comparator mycomparator = Collections.reverseOrder();

然后

只是想知道如何使用集合和比较器按升序排序？谢谢
 使用默认版本：

Collections.sort(myarrayList);

当然，这需要您的元素实现
compariable
，但您提到的版本也是如此

顺便说一句：您应该在代码中使用泛型，这样，如果您的类没有实现可比性，就会出现编译时错误。编译时错误比运行时错误要好得多

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

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

List List=new ArrayList（）；
//现在把清单填好
//除非MyClass实现了可比较的
集合。排序（列表）；
把这个扔出去……你就不能这样做：

Collections.sort(myarrayList);

但是已经有一段时间了…
有两种方法可以完成这一任务：

Collections.sort(myArray)

myArray中的给定元素实现了可比较的

第二

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

其中，
MyArrayElementComparator
是myArray内部元素的
比较器
，这里是一个完整的示例：

假设我们有一个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.Comparator；
公共类ComparePerson实现Comparator
{
@凌驾
公共整数比较（人员p1、人员p2）
{
if（p1.getFname（）.equalsIgnoreCase（p2.getFname（）））
{
返回p1.getLname（）.compareTo（p2.getLname（））；
}
返回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；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
公共课组
{
受保护人员名单；
公共组（）
{
this.listPersons=newArrayList（）；
}
公共团体（名单人员）
{
this.listPersons=listPersons；
}
公共无效命令（布尔asc）
{
Comparator comp=asc？new ComparePerson（）：Collections.reverseOrder（new ComparePerson（））；
Collections.sort（this.listPersons，comp）；
}
公共空间显示（）
{
for（人员p：此列表人员）
{
系统输出println（p）；
}
}
/**接球手和接球手**/
}

现在我们尝试一下：

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

import java.util.ArrayList；
导入java.util.List；
公共类应用程序
{
公共静态void main（字符串[]args）
{
g组=新组（）；
List listPersons=新建ArrayList（）；
g、 setListPersons（listPersons）；
人p；
p=新人（“A”、“B”）；
增加（p）；
p=新人（“C”、“D”）；
增加（p）；
/**您可以添加任意数量的人员**/
g、 显示（）；
g、 命令（真实）；
g、 显示（）；
g、 订单（虚假）；
g、 显示（）；
}
}
按值排序

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

这可能有用吗

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

谢谢，只是想知道可以定义一个比较器吗？@user1097097是的，阅读，它解释了比较器谢谢，只是想知道可以定义一个比较器吗？你搜索过论坛了吗？这个问题每天问一次。
Comparator mycomparator = 
    Collections.reverseOrder(Collections.reverseOrder());