如何在给定对象列表的情况下找到前 N 个？

Question

我想将键值对 存储在地图中，并根据以下逻辑根据 Key 的值（数据列表）对条目进行排序：

1. 按数据对象中的分数对每个键（组）的值（列表中）进行排序，并
2. 如果地图的大小大于 n（例如 n = 3） - 然后根据第一项的（值）分数对键（组）进行排序并返回 3。 - 相当于说获得前 3（每个中的 1组）基于高分

我希望每组（A、B、C、D）得到 1 个结果

 import java.util.ArrayList; 

public class MyClass {

    public static void main(String args[]) {
      
       // output should be just Data(17.0, "five", "D"), Data(4.0, "two", "A"), Data(3.0, "three", "B")
      ArrayList<Data> dataList = new ArrayList<Data>();
        dataList.add(new Data(1.0, "one", "A"));
        dataList.add(new Data(4.0, "two", "A"));
        dataList.add(new Data(3.0, "three", "B"));
        dataList.add(new Data(2.0, "four", "C"));
        dataList.add(new Data(7.0, "five", "D"));
        dataList.add(new Data(17.0, "five", "D"));
        
// output should be just Data(5.0, "six", "A"), Data(3.14, "two", "B"), Data(3.14, "three", "C")
      ArrayList<Data> dataList2 = new ArrayList<Data>();
        dataList2.add(new Data(3.0, "one", "A"));
        dataList2.add(new Data(5.0, "six", "A"));
        dataList2.add(new Data(3.14, "two", "B"));
        dataList2.add(new Data(3.14, "three", "C"));
        
      System.out.println("data 1=  " + dataList.size());
      System.out.println("data 2 =  " + dataList2.size());

    }
    
  static class Data {
     double score;
     String name; 
     String group;
     
      
    public Data(double score, String name, String group) {
        score = this.score;
        name = this.name;
        group = this.group;
    }
    
    public String getName() {
        return name;
    }
     
    public String getGroup() {
        return group;
    }
    
    public double getScore() {
        return score;
    }
    }
}

我知道执行此操作的程序方式，但在 Java 8 中是否有更智能/更实用的方式来执行此操作？

Answer 1

我希望每组（A、B、C、D）得到 1 个结果

和

我要存储键值对

以某种方式相互矛盾。但我假设您希望获得每个组中得分最高的条目，并将结果限制为某个给定大小n。如果这是真的，请尝试以下类似的方法来获取前 n 个元素的地图，其中 group 作为键，Data 对象本身作为值

long n = 3;

Map<String,Data> result =
            dataList.stream()
            .collect(Collectors.groupingBy(Data::getGroup,
                    Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingDouble(Data::getScore)),
                            Optional::get)))
            .entrySet()
            .stream()
                    .sorted(Comparator.comparing(e -> e.getValue().getScore(),Comparator.reverseOrder()))
                    .limit(n)
                    .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue,(a,b) -> a, LinkedHashMap::new));

result.entrySet().forEach(System.out::println);

得到

D=MyClass.Data(score=17.0, name=five, group=D)
A=MyClass.Data(score=4.0, name=two, group=A)
B=MyClass.Data(score=3.0, name=three, group=B)

或者，如果您只需要包含每个组中最大分数元素的列表的子列表（因为组值在对象本身中可用），则执行以下操作：

List<Data> result =
            dataList.stream()
            .collect(Collectors.groupingBy(Data::getGroup,
                    Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingDouble(Data::getScore)),
                            Optional::get)))
            .values()
            .stream()
                    .sorted(Comparator.comparingDouble(Data::getScore).reversed())
                    .limit(n)
                    .collect(Collectors.toList());
    result.forEach(System.out::println);

result.forEach(System.out::println);

得到

MyClass.Data(score=17.0, name=five, group=D)
MyClass.Data(score=4.0, name=two, group=A)
MyClass.Data(score=3.0, name=three, group=B)