如何在字段上使用RuleBasedCollat​​or对Java对象列表进行排序？

Question

我想使用给定的RuleBasedCollator对特定字段上的对象的ArrayList进行排序。

例如，我们有一个Thing对象列表：

public Thing {
  public String name;
  public String type;
}

List<Thing> things = new ArrayList<Thing>();

RuleBasedCollator ruleBasedCollator = new RuleBasedCollator("< Table < Plate < Fork < Knife");

现在，在创建Thing对象并将它们添加到things列表之后，我想对该列表进行排序，获得“表” type第一件事和“刀”类型的最后事物。

有人知道怎么做吗？

Answer 1

您可以尝试这样，而不是在Comparator的compare方法中使用compareTo，而可以调用RuleBasedCollat​​or的compare。

mQueue.sort((o1, o2) -> {
    if (o1.getDescription().getTitle() != null && o2.getDescription().getTitle() != null) {
        return mRuleBasedCollator.compare(o1.getDescription().getTitle().toString(),
            o2.getDescription().getTitle().toString());
    } else {
        return 0;
    }
});

Answer 2

据我了解， RuleBaseCollator用于对String进行排序，至少我在作为超级类的Collat​​or类中这样说。 我将改用比较器，如下所示：

public class ThingSorter {
public enum ThingType{      
    //wanted sort order, sort on ordinal :
    //Table < Plate < Fork < Knife      
    TABLE, PLATE, FORK, KNIFE
}

public static class Thing {
    private String name;
    private ThingType type;

    public Thing(String name, ThingType tt) {
        this.name = name;
        type = tt;          
    }

    public String toString() {
        return name + " [" + type + "]";
    }
}

public static class MyThingComparator implements Comparator<Thing> {
    @Override
    public int compare(Thing t1, Thing t2) {
        return t1.type.ordinal() - t2.type.ordinal();
    }
}
public static class MyReverseThingComparator implements Comparator<Thing> {
    @Override
    public int compare(Thing t1, Thing t2) {
        return t2.type.ordinal() - t1.type.ordinal();
    }
}

public static void main(String[] args) throws ParseException {
    List<Thing> things = new ArrayList<Thing>();
    things.add(new Thing("One", ThingType.KNIFE));
    things.add(new Thing("Two", ThingType.FORK));
    things.add(new Thing("Three", ThingType.PLATE));
    things.add(new Thing("Four", ThingType.TABLE));
    System.out.println("unsorted:\n" + things);

    Collections.sort(things, new MyThingComparable());  
    System.out.println("sorted:\n" + things);

    Collections.sort(things, new MyReverseThingComparable());   
    System.out.println("sorted:\n" + things);
}

}

在这种情况下，名称不涉及排序，仅涉及类型（以及类型中的序数）

Answer 3

我终于找到了使用TreeMap的解决方案。 我将“ type”属性用作键，并将Thing列表用作值。 我创建了一个ListBasedCollat​​or扩展了Collat​​or，而不是使用RuleBasedCollat​​or，因为RuleBasedCollat​​or规则适用于字符而不适用于单词。

public class ListBasedCollator extends Collator {

private List<String> list;

public ListBasedCollator(String[] array) {
    list = Arrays.asList(array);
}

@Override
public int compare(String source, String target) {
    if(!list.contains(target)) {
        return 1;
    }

    if(!list.contains(source)) {
        return -1;
    }

    return Integer.valueOf(list.indexOf(source)).compareTo(Integer.valueOf(list.indexOf(target)));
}

@Override
public CollationKey getCollationKey(String source) {
    return null;
}

@Override
public int hashCode() {
    return 0;
}

}

这是我构造TreeMap的方法：

String[] sortingList = {"TABLE", "PLATE", "FORK", "KNIFE"};
ListBasedCollator listBasedCollator = new ListBasedCollator(sortingList);
Map<String, List<Thing>> thingMap = new TreeMap<String, List<Thing>>(listBasedCollator);

因此，thingMap将始终使用listBasedCollat​​or按类型排序。 我还可以按字母顺序对每种不同类型的事物列表进行排序。

Answer 4

您当然可以使用TreeMap或enum如先前的答案所示； 一个更简单的替代方法是仅使用自定义的Compatator，而不使用enum 。 如果您使用的是Java 8，则可以将其简化为一行：

Collections.sort(things,
                 (Thing t1, Thing t2)->ruleBasedCollator.compare(t1.type, t2.type) );

8之前的版本将使用匿名Comparator执行相同的操作