如何在不同的时间按不同的参数对列表进行排序

95

我有一个Person具有多个属性的类，例如：

public class Person {
    private int id;
    private String name, address;
    // Many more properties.
}

很多Person对象都存储在中ArrayList<Person>。我想通过多个排序参数对列表进行排序，但有时会有所不同。例如，我可能想一次按name升序然后再address降序排序，而另一次只想按id降序排序。

而且我不想创建自己的排序方法（即，我想使用Collections.sort(personList, someComparator)。）实现此目的的最优雅的解决方案是什么？

java  sorting 
— 拉纳罗斯
source

Answers:

193

我认为您的枚举方法基本上是正确的，但是switch语句确实需要一种更加面向对象的方法。考虑：

enum PersonComparator implements Comparator<Person> {
    ID_SORT {
        public int compare(Person o1, Person o2) {
            return Integer.valueOf(o1.getId()).compareTo(o2.getId());
        }},
    NAME_SORT {
        public int compare(Person o1, Person o2) {
            return o1.getFullName().compareTo(o2.getFullName());
        }};

    public static Comparator<Person> decending(final Comparator<Person> other) {
        return new Comparator<Person>() {
            public int compare(Person o1, Person o2) {
                return -1 * other.compare(o1, o2);
            }
        };
    }

    public static Comparator<Person> getComparator(final PersonComparator... multipleOptions) {
        return new Comparator<Person>() {
            public int compare(Person o1, Person o2) {
                for (PersonComparator option : multipleOptions) {
                    int result = option.compare(o1, o2);
                    if (result != 0) {
                        return result;
                    }
                }
                return 0;
            }
        };
    }
}

用法示例（带有静态导入）。

public static void main(String[] args) {
    List<Person> list = null;
    Collections.sort(list, decending(getComparator(NAME_SORT, ID_SORT)));
}
— 义斋
source
12
+1明智地使用枚举。我喜欢您与枚举的优雅组合，即“降序”和“复合”。我猜想缺少空值处理，但是添加与“降序”相同的方法很容易。
— KLE
1
许多不错的答案令人深思。由于没有答案可以作为一个明显的替代方案，因此我会接受这个答案，因为我喜欢优雅，但是我强烈建议任何查看此答案的人也检查其他方法。
— runaros
1
@TheLittleNaruto，如果o2较大，则compare方法返回负数；如果o1较大，则compare方法返回正数；如果相等，则返回零。乘以-1将反转结果，即下降的想法（与通常的升序相反），如果相等，则将其保留为零。
— Yishai 2013年
5
请注意，从Java 8开始，您可以使用comparator.reversed()降序，也可以使用comparator1.thenComparing(comparator2)链接比较器。
— GuiSim 2015年
1
@JohnBaum，如果第一个比较器返回非零结果，则返回该结果，并且不执行链的其余部分。
— Yishai 2015年
26

您可以为可能要排序的每个属性创建比较器，然后尝试“比较器链接” :-)，如下所示：

public class ChainedComparator<T> implements Comparator<T> {
    private List<Comparator<T>> simpleComparators; 
    public ChainedComparator(Comparator<T>... simpleComparators) {
        this.simpleComparators = Arrays.asList(simpleComparators);
    }
    public int compare(T o1, T o2) {
        for (Comparator<T> comparator : simpleComparators) {
            int result = comparator.compare(o1, o2);
            if (result != 0) {
                return result;
            }
        }
        return 0;
    }
}
— 塔德乌斯·科佩克（Tadeusz Kopec）
source
使用该警告时，您可能会收到一条警告（尽管在JDK7中，您应该可以取消警告）。
— 汤姆·哈特芬
我也喜欢 您能否在给出的示例中提供有关如何使用它的示例？
— runaros
@runaros：使用KLE答案中的比较器：Collections.sort（/ * Collection <Person> * /人，新的ChainedComparator（NAME_ASC_ADRESS_DESC，ID_DESC））;
— Janus Troelsen，
16

一种方法是创建一个Comparator以属性作为排序依据的参数，如本示例所示。

public class Person {
    private int id;
    private String name, address;

    public static Comparator<Person> getComparator(SortParameter... sortParameters) {
        return new PersonComparator(sortParameters);
    }

    public enum SortParameter {
        ID_ASCENDING, ID_DESCENDING, NAME_ASCENDING,
        NAME_DESCENDING, ADDRESS_ASCENDING, ADDRESS_DESCENDING
    }

    private static class PersonComparator implements Comparator<Person> {
        private SortParameter[] parameters;

        private PersonComparator(SortParameter[] parameters) {
            this.parameters = parameters;
        }

        public int compare(Person o1, Person o2) {
            int comparison;
            for (SortParameter parameter : parameters) {
                switch (parameter) {
                    case ID_ASCENDING:
                        comparison = o1.id - o2.id;
                        if (comparison != 0) return comparison;
                        break;
                    case ID_DESCENDING:
                        comparison = o2.id - o1.id;
                        if (comparison != 0) return comparison;
                        break;
                    case NAME_ASCENDING:
                        comparison = o1.name.compareTo(o2.name);
                        if (comparison != 0) return comparison;
                        break;
                    case NAME_DESCENDING:
                        comparison = o2.name.compareTo(o1.name);
                        if (comparison != 0) return comparison;
                        break;
                    case ADDRESS_ASCENDING:
                        comparison = o1.address.compareTo(o2.address);
                        if (comparison != 0) return comparison;
                        break;
                    case ADDRESS_DESCENDING:
                        comparison = o2.address.compareTo(o1.address);
                        if (comparison != 0) return comparison;
                        break;
                }
            }
            return 0;
        }
    }
}

然后可以在例如以下代码中使用它：

cp = Person.getComparator(Person.SortParameter.ADDRESS_ASCENDING,
                          Person.SortParameter.NAME_DESCENDING);
Collections.sort(personList, cp);
— 拉纳罗斯
source
是。如果您希望代码非常通用，则枚举可以仅指定要读取的属性（可以使用反射使用枚举名称来获取属性），还可以使用第二个枚举指定其余的属性：ASC和DESC，以及可能是三分之一（NULL_FIRST或NULL_LAST）。
— KLE
8

一种方法是撰写Comparator。这可能是一个库方法（我确定它存在于某处）。

public static <T> Comparator<T> compose(
    final Comparator<? super T> primary,
    final Comparator<? super T> secondary
) {
    return new Comparator<T>() {
        public int compare(T a, T b) {
            int result = primary.compare(a, b);
            return result==0 ? secondary.compare(a, b) : result;
        }
        [...]
    };
}

用：

Collections.sort(people, compose(nameComparator, addressComparator));

另外，请注意这Collections.sort是一种稳定的排序方式。如果性能不是绝对关键，则将您排在次要顺序之前。

Collections.sort(people, addressComparator);
Collections.sort(people, nameComparator);
— 汤姆·霍顿-大头钉
source
但是，是否可以采用更聪明的方法，使其包含更多数量的比较器，可能包括零个？
— runaros
compose(nameComparator, compose(addressComparator, idComparator))如果Java有扩展方法，那会更好一点。
— 汤姆·哈特芬
4

比较器使您可以非常轻松自然地执行此操作。您可以在Person类本身或与您的需求相关的Service类中创建比较器的单个实例。
使用匿名内部类的示例：

    public static final Comparator<Person> NAME_ASC_ADRESS_DESC
     = new Comparator<Person>() {
      public int compare(Person p1, Person p2) {
         int nameOrder = p1.getName().compareTo(p2.getName);
         if(nameOrder != 0) {
           return nameOrder;
         }
         return -1 * p1.getAdress().comparedTo(p2.getAdress());
         // I use explicit -1 to be clear that the order is reversed
      }
    };

    public static final Comparator<Person> ID_DESC
     = new Comparator<Person>() {
      public int compare(Person p1, Person p2) {
         return -1 * p1.getId().comparedTo(p2.getId());
         // I use explicit -1 to be clear that the order is reversed
      }
    };
    // and other comparator instances as needed...

如果有很多，您还可以按自己喜欢的方式构造比较器代码。例如，您可以：

  • 从另一个比较器继承，
  • 有一个CompositeComparator，它聚合了一些现有的比较器
  • 有一个NullComparator处理空的情况，然后委托给另一个比较器
  • 等等...
— 凯乐
source
2

我认为，将排序器耦合到Person类（就像您的答案一样）不是一个好主意，因为它将比较（通常是业务驱动）与模型对象彼此耦合在一起。每次您要更改/添加分类器时，都需要触摸人员分类，这通常是您不想执行的操作。

使用提供Comparator实例的服务或类似服务（如建议的KLE）听起来更加灵活和可扩展。

— 贾
source
对我来说，这导致紧密耦合，因为比较者持有人类以某种方式必须知道Person类的详细数据结构（基本上是要比较的Person类的哪些字段），并且如果您要在Persons字段中进行某些更改，则会导致跟踪相同的内容比较器类的变化。我猜Person比较器应该是Person类的一部分。blog.sanaulla.info/2008/06/26/…–
— 斯坦（Stan）
2

我的方法是基于Yishai的。主要差距在于，没有办法对一个属性的升序进行排序，然后再对另一个降序进行排序。枚举无法做到这一点。为此，我使用了类。因为SortOrder强烈取决于类型，所以我更喜欢将其实现为人员的内部类。

具有内部类“ SortOrder”的类“ Person”：

import java.util.Comparator;

public class Person {
    private int id;
    private String firstName; 
    private String secondName;

    public Person(int id, String firstName, String secondName) {
        this.id = id;
        this.firstName = firstName;
        this.secondName = secondName;   
    }

    public abstract static class SortOrder implements Comparator<Person> {
        public static SortOrder PERSON_ID = new SortOrder() {
            public int compare(Person p1, Person p2) {
                return Integer.valueOf(p1.getId()).compareTo(p2.getId());
            }
        };
        public static SortOrder PERSON_FIRST_NAME = new SortOrder() {
            public int compare(Person p1, Person p2) {
                return p1.getFirstName().compareTo(p2.getFirstName());
            }
        };
        public static SortOrder PERSON_SECOND_NAME = new SortOrder() {
            public int compare(Person p1, Person p2) {
                return p1.getSecondName().compareTo(p2.getSecondName());
            }
        };

        public static SortOrder invertOrder(final SortOrder toInvert) {
            return new SortOrder() {
                public int compare(Person p1, Person p2) {
                    return -1 * toInvert.compare(p1, p2);
                }
            };
        }

        public static Comparator<Person> combineSortOrders(final SortOrder... multipleSortOrders) {
            return new Comparator<Person>() {
                public int compare(Person p1, Person p2) {
                    for (SortOrder personComparator: multipleSortOrders) {
                        int result = personComparator.compare(p1, p2);
                        if (result != 0) {
                            return result;
                        }
                    }
                    return 0;
                }
            };
        }
    }

    public int getId() {
        return id;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getSecondName() {
        return secondName;
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();

        result.append("Person with id: ");
        result.append(id);
        result.append(" and firstName: ");
        result.append(firstName);
        result.append(" and secondName: ");
        result.append(secondName);
        result.append(".");

        return result.toString();
    }
}

使用Person类及其SortOrder的示例：

import static multiplesortorder.Person.SortOrder.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import multiplesortorder.Person;

public class Application {

    public static void main(String[] args) {
        List<Person> listPersons = new ArrayList<Person>(Arrays.asList(
                 new Person(0, "...", "..."),
                 new Person(1, "...", "...")
             ));

         Collections.sort(listPersons, combineSortOrders(PERSON_FIRST_NAME, invertOrder(PERSON_ID)));

         for (Person p: listPersons) {
             System.out.println(p.toString());
         }
    }
}

奥鲁莫

— 奥鲁莫
source
这种比较器链接的复杂性是什么？每次链接比较器时，我们是否在本质上进行排序？那么我们为每个比较器执行一个* log（n）操作吗？
— 约翰·鲍姆
0

我最近写了一个Comparator来对分隔的String记录中的多个字段进行排序。它允许您定义定界符，记录结构和排序规则（其中一些是特定于类型的）。您可以通过将Person记录转换为定界的String来使用它。

所需信息可以通过编程方式或通过XML文件播种到比较器本身。

XML由程序包嵌入式XSD文件验证。例如，下面是一个制表符分隔的记录布局，其中包含四个字段（其中两个是可排序的）：

<?xml version="1.0" encoding="ISO-8859-1"?> 
<row xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <delimiter>&#009;</delimiter>

    <column xsi:type="Decimal">
        <name>Column One</name>
    </column>

    <column xsi:type="Integer">
        <name>Column Two</name>
    </column>

    <column xsi:type="String">
        <name>Column Three</name>
        <sortOrder>2</sortOrder>
        <trim>true</trim>
        <caseSensitive>false</caseSensitive>        
        <stripAccents>true</stripAccents>
    </column>

    <column xsi:type="DateTime">
        <name>Column Four</name>
        <sortOrder>1</sortOrder>
        <ascending>true</ascending>
        <nullLowSortOrder>true</nullLowSortOrder>
        <trim>true</trim>
        <pattern>yyyy-MM-dd</pattern>
    </column>

</row>

然后，您可以在Java中像这样使用它： 

Comparator<String> comparator = new RowComparator(
              new XMLStructureReader(new File("layout.xml")));

图书馆可以在这里找到：

http://sourceforge.net/projects/multicolumnrowcomparator/

— 康斯坦丁
source
0

假设有一类Coordinate，并且必须根据X坐标和Y坐标以两种方式对它进行排序。为此需要两个differnet比较器。下面是示例

class Coordinate
{

    int x,y;

    public Coordinate(int x, int y) {
        this.x = x;
        this.y = y;
    }

    static Comparator<Coordinate> getCoordinateXComparator() {
        return new Comparator<Coordinate>() {

            @Override
            public int compare(Coordinate Coordinate1, Coordinate Coordinate2) {
                if(Coordinate1.x < Coordinate2.x)
                    return 1;
                else
                    return 0;
            }
            // compare using Coordinate x
        };
    }

    static Comparator<Coordinate> getCoordinateYComparator() {
        return new Comparator<Coordinate>() {

            @Override
            public int compare(Coordinate Coordinate1, Coordinate Coordinate2) {
                if(Coordinate1.y < Coordinate2.y)
                    return 1;
                else
                    return 0;
            }
            // compare using Coordinate y
        };
    }
}
— 拉维·兰詹
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.