列表排序难题

Question

假设我有

final Iterable<String> unsorted = asList("FOO", "BAR", "PREFA", "ZOO", "PREFZ", "PREFOO");

什么可以将这个未排序的列表转换为：（

[PREFZ, PREFA, BAR, FOO, PREFOO, ZOO]

一个以必须首先出现的已知值开头的列表（此处为“PREFA”和“PREFZ”），其余部分按字母顺序排序）

我认为有一些有用的番石榴中的类可以完成这项工作（排序、谓词...），但我还没有找到解决方案...

Answer 1

我会保留单独的清单。

一种用于已知值和未知值。并将它们分开排序，当您需要将它们放在一个列表中时，您可以将它们连接起来。

knownUnsorted.addAll(unsorted.size - 1, unknonwUnsorted);

Answer 2

我建议填写 List 与您的值并使用 Collections.sort(...)。

像

Collections.sort(myList, new FunkyComparator());

这样使用：

class FunkyComparator implements Comparator {

    private static Map<String,Integer> orderedExceptions =
        new HashMap<String,Integer>(){{ 
            put("PREFZ", Integer.valueOf(1));
            put("PREFA", Integer.valueOf(2));
        }};

    public int compare(Object o1, Object o2) {
        String s1 = (String) o1;
        String s2 = (String) o2;
        Integer i1 = orderedExceptions.get(s1);
        Integer i2 = orderedExceptions.get(s2);

        if (i1 != null && i2 != null) {
            return i1 - i2;
        }
        if (i1 != null) {
            return -1;
        }
        if (i2 != null) {
            return +1;
        }
        return s1.compareTo(s2);
    }
}

Answer 3

注意：这不是最有效的解决方案。这只是一个简单、直接的解决方案，可以完成工作。

我首先使用 Collections.sort(list) 对列表进行排序。

然后，我会删除已知的项目，并将它们添加到前面。

String special = "PREFA";
if (list.remove(special)
    list.add(0, special);

或者，如果您在前面有需要的这些值的数组列表，您可以执行以下操作：

String[] knownValues = {};
for (String s: knownValues) {
    if (list.remove(s))
        list.add(0, s);
}

Answer 4

由于我是番石榴库的粉丝，我想找到一个使用它的解决方案。我不知道它是否有效，也不知道您是否发现它像其他解决方案一样简单，但它在这里：

final Iterable<String> all = asList("FOO", "BAR", "PREFA", "ZOO", "PREFOO", "PREFZ");
final List<String> mustAppearFirst = asList("PREFZ", "PREFA");
final Iterable<String> sorted = 
      concat(
            Ordering.explicit(mustAppearFirst).sortedCopy(filter(all, in(mustAppearFirst))),
            Ordering.<String>natural().sortedCopy(filter(all, not(in(mustAppearFirst)))));

Answer 5

你特别提到了番石榴；与 Sylvain M 的答案一起，这是另一种方法（更多的是作为学术练习和番石榴灵活性的演示）

// List is not efficient here; for large problems, something like SkipList 
// is more suitable
private static final List<String> KNOWN_INDEXES = asList("PREFZ", "PREFA");

private static final Function<Object, Integer> POSITION_IN_KNOWN_INDEXES 
    = new Function<Object, Integer>() {
  public Integer apply(Object in) {
     int index = KNOWN_INDEXES.indexOf(in);
     return index == -1 ? null : index;
  }     
};


...


List<String> values = asList("FOO", "BAR", "PREFA", "ZOO", "PREFZ", "PREFOO");

Collections.sort(values,
  Ordering.natural().nullsLast().onResultOf(POSITION_IN_KNOWN_INDEXES).compound(Ordering.natural())
);

因此，换句话说，对 List 返回的 Integer 的自然顺序进行排序.indexOf()，然后打破与对象本身的自然顺序的联系。

也许很混乱，但很有趣。

Answer 6

我也会使用 Collections.sort(list) 但我想我会使用比较器，在比较器中您可以定义自己的规则，例如然后

class MyComparator implements Comparator<String> {

    public int compare(String o1, String o2) {
        // Now you can define the behaviour for your sorting.
        // For example your special cases should always come first, 
        // but if it is not a special case then just use the normal string comparison.

        if (o1.equals(SPECIAL_CASE)) {
            // Do something special
        }
        // etc.
        return o1.compareTo(o2);
    }

}

通过执行以下操作进行排序：

Collections.sort(list, new MyComparator());