根据复杂条件列出元素顺序

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

您可以使用 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);

Answer 3

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

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

根据复杂条件列出元素顺序

List elements order depending on complex condition

groovy

jenkins

jenkins-pipeline