java - 循环并获取最后一个总值

Question

假设我有一个列表和一个结果

[
  {
      "userTaskId": 10,
      "counter": 1,
      "userName" : "test name one"
  },
  {
      "userTaskId": 10,
      "counter": 2,
      "userName" : "test name two"
  },
  {
      "userTaskId": 10,
      "counter": 3,
      "userName" : "test name three"
  },
  {
      "userTaskId": 20,
      "counter": 1,
      "userName" : "test name"
  },
  {
      "userTaskId": 20,
      "counter": 1,
      "userName" : "test name four"
  },
  {
      "userTaskId": 20,
      "counter": 3,
      "userName" : "test name five"
  },
]

我会遍历它

List<UserModel> savedUser = userRepository.findAll();

for (UserModel user: savedUser) {
    Double number = user.getCounter() * 1000;

    /* 
     * number result will be
     * 1000 -> userTaskId: 10
     * 2000 -> userTaskId: 10
     * 3000 -> userTaskId: 10
     * 1000 -> userTaskId: 20
     * 1000 -> userTaskId: 20
     * 3000 -> userTaskId: 20
     */
}

现在我的问题是如何在总数变为不同的userTaskId之前获得总数。现在我实现了：

Double holder = 0D;
Set<Long> test = new HashSet<>();
Double total = 0D;
List<UserModel> savedUser = userRepository.findAll();
for (UserModel user: savedUser) {
    Double number = user.getCounter() * 1000;
    Long userTaskId = user.getTaskId();


    if (test.contains(limitNo)){
         total += number;
    } else {
         // Save the total value to temporary variable before resetting the total
         holder = total;
         System.out.println(holder);
         total = number;

         test.add(userTaskId);
    }

    /* 
     * total result will be
     * 1000 -> userTaskId: 10
     * 3000 -> userTaskId: 10
     * 6000 -> userTaskId: 10 (I want to get this value)
     * 1000 -> userTaskId: 20
     * 2000 -> userTaskId: 20
     * 5000 -> userTaskId: 20 (I want to get this value)
     */
}

我想得到值6000 和 5000但是我只得到值：

0.0 and 6000

关于如何仅获得这些值的任何想法？

Answer 1

试试这个：

import :
import java.util.List;
import java.util.Map;

import static java.util.stream.Collectors.*;

///////////

Map<Long, Double> getResponse(List<UserModel> savedUser) throws Exception{
        Map<Long, Double> ans = savedUser.stream()
                .collect(groupingBy(UserModel::getUserTaskId, summingDouble(this::getValue)));
        return ans;
    }

private Double getValue(UserModel  userModel) {
    return userModel.getCounter() * 1000;
}

这是for循环代码：

savedUser.sort((a,b)-> a.getUserTaskId() <= b.getUserTaskId() ? -1 : 1);
        int len = savedUser.size();
        int prev = 0;
        double total = savedUser.get(0).getCounter() * 1000;
        for (int i = 1; i < len; i++) {
            if (savedUser.get(i).getUserTaskId() != savedUser.get(prev).getUserTaskId()) {
                // here from prev to i-1 one group
                // total contains summation of this group
                // do your task
                prev = i;
                total = savedUser.get(i).getCounter() * 1000;
            } else {
                total += (savedUser.get(i).getCounter() * 1000);
            }
        }
        //here is another group from prev to len-1
        //total contains summation of this group
        //do your task