使用 Java Stream API 按降序对数组进行部分排序

Question

我需要知道如何使用 Stream API 按降序对原始唯一整数数组进行部分排序。例如，如果有一个像 {1,2,3,4,5} 这样的数组，我想得到 {5,4,3, 1,2} - 首先是 3 个最大的元素，然后是其余的。甚至可以使用流吗？我检查了文档 - 有两种方法 skip 和 limit 但它们会更改流内容并从数组的开头开始工作。

我可以像这样对整个数组进行排序

Arrays.stream(arr)
.boxed()
.sorted(Collections.reverseOrder())
.mapToInt(Integer::intValue)
.toArray();

但是如何使这种排序局部化？我说 Stream API 是因为我希望它写得很好。

我也直觉地觉得concat 可能会在这里一展身手。我可以考虑的另一种方法是使用自定义比较器来限制排序元素的数量。你怎么看？

附：我不是 Java 专家。

Answer 1

我需要知道如何使用 Stream API 按降序对原始整数数组进行部分排序。

没有可让您在 Java 中执行此操作的内置工具。在 Stream API 和 Collections API 中都没有。你要么需要自己实现它，要么改变你的方法。

我说 Stream API 是因为我希望它写得很好。

使用 Java 8 Streams 并不意味着您的代码会写得很好。流是不是通用工具。有时它们提供增强的可读性，有时您必须使用其他东西。

我可以考虑的另一种方法是使用自定义比较器来限制排序元素的数量。

那无法做到，因为Comparator 不知道有多少元素已排序。简单地计算调用次数不会为您提供这方面的任何有意义的信息。

---

我的建议是实现类似于C++ 的std::partial_sort，这很可能基于heap approach。

Answer 2

您将无法使用流很好地做到这一点。这是一种方法：

public static void main(String[] args) {

    Integer[] arr = {1, 2, 3, 4, 5};
    List<Integer> originalValues = new ArrayList<>(Arrays.asList(arr));

    ArrayList<Integer> list = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        originalValues.stream().max(Integer::compareTo).ifPresent(v -> {
            list.add(v);
            originalValues.remove(v);
        });
    }
    list.addAll(originalValues);

    System.out.println(list);
    // [5, 4, 3, 1, 2]
}

Answer 3

这是一种使用流的方法。

int[] sortPartially(int[] inputArray, int limit) {
    Map<Integer, Long> maxValues = IntStream.of(inputArray)
                                            .boxed()
                                            .sorted(Comparator.reverseOrder())
                                            .limit(limit)
                                            .collect(Collectors.groupingBy(x -> x, LinkedHashMap::new, Collectors.counting()));

    IntStream head = maxValues.entrySet()
                              .stream()
                              .flatMapToInt(e -> IntStream.iterate(e.getKey(), i -> i)
                                                          .limit(e.getValue().intValue()));

    IntStream tail = IntStream.of(inputArray)
                              .filter(x -> {
        Long remainingDuplication = maxValues.computeIfPresent(x, (y, count) -> count - 1);
        return remainingDuplication == null || remainingDuplication < 0;
    });

    return IntStream.concat(head, tail).toArray();
}

上面的例子当然是对整个输入数组进行排序，但保持未排序元素的顺序稳定。

另一个使用优先级队列的流示例（正如其他人提到的）降低了运行时复杂性：

Collection<Integer> sortPartially(int[] inputArray, int sortedPartLength) {
    Queue<Integer> pq = new PriorityQueue<>(sortedPartLength);

    Deque<Integer> result = IntStream.of(inputArray).boxed().map(x -> {
        pq.add(x);
        return pq.size() > sortedPartLength ? pq.poll() : null;
    }).filter(Objects::nonNull).collect(Collectors.toCollection(ArrayDeque::new));

    Stream.generate(pq::remove).limit(sortedPartLength).forEach(result::addFirst);

    return result;
}

如果输入数组中有重复，未排序元素的顺序可以改变。

Answer 4

我会将三个最大的元素保存在一个集合中，然后定义我自己的比较器。

 public static void main(String[] args){
    int[] input = {1,2,3,4,5};
    Set<Integer> set = Arrays.stream(input).boxed().sorted(Comparator.reverseOrder()).limit(3).collect(Collectors.toSet());
    Comparator<Integer> customComp = (a,b) -> { 
        if(set.contains(a) && set.contains(b)){ return a.compareTo(b);}
        else if(set.contains(a)){ return 1;}
        else if(set.contains(b)){ return -1;}
        else { return 0;}
    };
    int[] sorted = Arrays.stream(input).boxed().sorted(customComp.reversed()).mapToInt(i->i).toArray();
    System.out.println(Arrays.toString(sorted));
}

Answer 5

虽然代码比公认的答案长，但它的排序要少得多：对于大数组，这很重要：

private static int[] partiallySorted(int[] input, int bound) {
    int[] result = new int[input.length];

    int i = -1;
    PriorityQueue<Integer> pq = new PriorityQueue<>(bound, Comparator.naturalOrder());
    for (int x : input) {
        pq.add(x);
        if (pq.size() > bound) {
            int el = pq.poll();
            result[bound + ++i] = el;
        }
    }

    while (!pq.isEmpty()) {
        result[--bound] = pq.poll();
    }

    return result;
}