Java收集到列表但指定预定义的前两个元素顺序

Question

我有一个List<Person> 对象。从中我想获得所有 id 的列表，并且我总是希望 id “abc”和“bob”作为列表的第 0 和第 1 个索引（如果可用）。有没有办法用java流做到这一点？

class Person {
   private String id;
}

List<Person> allPeople = ...
List<String> allIds = allPeople.stream().map(Person::id).collect(Collectors.toList());

我的做法是：

Set<String> allIds = allPeople.stream().map(Person::id).collect(Collectors.Set());
List<String> orderedIds = new ArrayList<>();
if(allIds.contains("abc")) {
   orderedIds.add("abc");
}
if(allIds.contains("bob")) {
   orderedIds.add("bob");
}
//Iterate through the set and all add all entries which are not bob and abc in the list.

Answer 1

您似乎需要更多PriorityQueue 而不是List，所以可能是这样的：

PriorityQueue<String> pq = list.stream()
            .map(Person::getId)
            .distinct()
            .collect(Collectors.toCollection(() -> new PriorityQueue<>(
                    Comparator.comparing(x -> !"abc".equals(x))
                            .thenComparing(x -> !"bob".equals(x)))));

如果您仍然需要 List，只需将 pq 合并为一个：

List<String> result = new ArrayList<>();
while (!pq.isEmpty()) {
   result.add(pq.poll());
}

Answer 2

我假设每个 id 在列表中只出现一次。有了这个，我会选择一个简单直接的解决方案：

List<Person> allPeople = ...;
List<String> allIds = allPeople.stream().map(Person::id).collect(toCollection(ArrayList::new));
boolean foundBob = allIds.remove("bob");
if (foundBob) allIds.add(0, "bob");
boolean foundAbc = allIds.remove("abc");
if (foundAbc) allIds.add(0, "abc");

请注意，"bob" 和 "abc" 以相反的顺序移至列表的头部。所以"abc"到底是第一位的。

你可以制作一个移动元素的小实用方法：

static void moveToHead(List<String> list, String elem) {
  boolean found = list.remove(elem);
  if (found) list.add(0, elem);
}

有了这个，你的代码更简单，更容易理解：

List<Person> allPeople = ...;
List<String> allIds = allPeople.stream().map(Person::id).collect(toCollection(ArrayList::new));
moveToHead(allIds, "bob");
moveToHead(allIds, "abc");

Answer 3

如果您想在“完全”流管道中执行此操作，您可以这样做：

allPeople.stream()
         .map(Person::id)
         .distinct()
         .collect(collectingAndThen(partitioningBy(s -> "abc".equals(s) || "bob".equals(s)), 
                    map -> Stream.concat(map.get(true).stream(), map.get(false).stream())));
         .collect(toList());

如果你总是想在“bob”前面加上“abc”，那就改

map.get(true).stream()

到

map.get(true).stream()
    .sorted(Comparator.comparing((String s) -> !s.equals("abc")))

---

您可以做的另一个解决方案是：

Set<String> allIds = allPeople.stream().map(Person::id).collect(toSet());
List<String> orderedIds = Stream.concat(allIds.stream()
                        .filter(s -> "abc".equals(s) || "bob".equals(s))
                        .sorted(Comparator.comparing((String s) -> !s.equals("abc"))),
                allIds.stream().filter(s -> !"abc".equals(s) && !"bob".equals(s)))
                .collect(toList());

这与上述partitioningBy 几乎相同，只是方法不同。

---

最后，您可能会感到惊讶，但您的方法实际上看起来不错，因此您可能希望通过以下方式完成它：

Set<String> allIds = allPeople.stream().map(Person::id).collect(toSet());

List<String> orderedIds = new ArrayList<>();

if(allIds.contains("abc")) 
    orderedIds.add("abc");

if(allIds.contains("bob")) 
    orderedIds.add("bob");

orderedIds.addAll(allIds.stream().filter(s -> !"abc".equals(s) && ! "bob".equals(s)).collect(toList()));

Answer 4

受 Stuart Marks 的启发，有一个更简单的解决方案：

List<String> allIds = allPeople.stream()
      .map(Person::getId)
      .distinct()
      .sorted(comparing(x -> !"abc".equals(x)).thenComparing(x -> !"bob".equals(x)))
      .collect(Collectors.toList());