Question

我们说，我有一个清单：

unordered_list = ['c-1','a-2','a-4','b-2','a-1','b-3','c-3','c-4']

我有一些条件：

应该追加以3结尾的第一个元素（但应保留从a到c的顺序）
然后列表应从a到c
但是当从a到c订购时，必须从1到3

结果应如下所示：

ordered_list = ['b-3','c-3','a-1','a-2','a-4','b-2','c-1','c-4']

我花了很多时间在 Groovy 中找到一些有效的方式来实现它，但是没有成功，因为我是初学者。任何提示将不胜感激。提前谢谢！

Answer 1

您可以编写比较器，如下所示：

Arrays.sort(unordered_list, new Comparator<String>() {

    @Override
    public int compare(String o1, String o2) {
       String[] o1s = o1.split('-');
       String[] o2s = o2.split('-');
       boolean end1_3 = o1s[1].equals("3");
       boolean end2_3 = o2s[1].equals("3");
       if(end1_3 && end2_3) {
           return 0; //both end with 3
       } else if(end1_3) {
           return -1; //only the first ends with 3, so less than
       } else if(end2_3) {
           return 1; //only the second ends with 3, so greater than
       }
       if(!o1s[0].equals(o2s[0])) { // first group not same
           return o1s[0].compareTo(o2s[0]); // compare first groups
       }
       return o1s[1].compareTo(o2s[1]); // assume equal
    }
});

Answer 2

不需要所有其他列表，您可以直接流式传输数组

    Stream.concat(Stream.of(unordered_list)
                    .filter(s -> s.endsWith("3"))
                    .sorted(),
            Stream.of(unordered_list))
            .filter(s -> !s.endsWith("3"))
            .sorted()
            .collect(toList());

或实际列表：

    List<String> unorderedList = asList("c-1", "a-2", "a-4", "b-2", "a-1", "b-3", "c-3", "c-4");
    Stream.concat(unorderedList.stream()
                    .filter(s -> s.endsWith("3"))
                    .sorted(),
            unorderedList.stream()
                    .filter(s1 -> !s1.endsWith("3"))
                    .sorted())
            .collect(toList());

最后，使用分区的另一种方式

    Map<Boolean, List<String>> endsWith3Partition = Stream.of(unordered_list)
            .sorted()
            .collect(partitioningBy(s -> s.endsWith("3")));
    List<String> sorted = new ArrayList<>(unordered.length);
    sorted.addAll(endsWith3Partition.get(true));
    sorted.addAll(endsWith3Partition.get(false));

Answer 3

您可以使用Java 8的stream来完成此操作，例如：

List<String> list = Arrays.asList(new String[]{"c-1","a-2","a-4","b-2","a-1","b-3","c-3","c-4"});

TreeMap<Boolean, List<String>> lists = list.stream()
.collect(Collectors.groupingBy(s -> s.toString().endsWith("3"), TreeMap::new, Collectors.toList()));

final List<String> result = new ArrayList<>();

lists.descendingMap().forEach((k, v) -> {
    Collections.sort(v);
    result.addAll(v);
});

System.out.println(result);

列出元素顺序取决于复杂条件

3 个答案: