Sum up List to a limit with streams

The problems of solving this with Stream API is that you have to keep some information outside of the context of processing and read/update (depend) on it at the same time. These tasks are not suitable for Stream API.

Use a for-loop instead which is suitable and great for this:

int index = 0;                              // highest index possible
int sum = 0;                                // sum as a temporary variable
for (int i=0; i<recordList.size(); i++) {   // for each Record
	sum += recordList.get(i).getCount();    // ... add the 'count' to the 'sum'
	if (sum <= limit) {                     // ... until the sum is below the limit
		index = i;                          // ... move the pivot
	} else break;                           // ... or else stop processing
}

// here you need to get the list from 0 to index+1 
// as long as the 2nd parameter of subList(int, int) is exlcusive
List<Record> filteredRecords = recordList.subList(0, index + 1);

This is the only thing I could come up with but it's not as efficient as a regular loop because it runs for each list entry it has. That also causes it to add other values further down. For example if limit was 46, third entry where count is 5 would be skipped but the next entry with count 2 would be still added. Don't know if this is desired behavior for you

    AtomicInteger count = new AtomicInteger();

    recordList = recordList.stream().filter(r -> {
        if(count.get() + r.count <= limit){
            count.addAndGet(r.count);
            return true;
        }
        return false;
    }).collect(Collectors.toList());

Adding the following toString to your class for printing you can do it as follows:

public String toString() {
    return String.format("[%s, %s]", recordID, count);
}

• Allocate a List to store the results
• initialize the sum
• iterate thru the list, summing the count until the
  threshhold is reached.

List<Records> results = new ArrayList<>();
int sum = 0;
for (Records rec : recordList) {
     // sum the counts
     sum += rec.getCount();
     if (sum > limit) {
        // stop when limit exceeded
        break;
     }
     results.add(rec);
}
        
results.forEach(System.out::println);       

Prints

[100, 10]
[501, 20]
[302, 5]


</details>



# 答案4
**得分**: 0

使用Java 8，您可以这样做：

```java
public static void main(String[] args) {
    int limit = 35;
    List<Records> recordList = new ArrayList<>();
    recordList.add(new Records(100, 10));
    recordList.add(new Records(501, 20));
    recordList.add(new Records(302, 5));
    recordList.add(new Records(405, 2));
    recordList.add(new Records(918, 8));

    List<Records> limitedResult = recordList.stream().filter(new Predicate<Records>() {
        int sum = 0;
        @Override
        public boolean test(Records records) {
            sum = sum + records.getCount();
            return sum <= limit;
        }
    }).collect(Collectors.toList());
    // 对limitedResult进行操作
    System.out.println(limitedResult);
}

编辑：

或者您可以创建一个返回Predicate的函数，以便重用，例如：

// 可重用的Predicate
public static Predicate<Records> limitRecordPredicate(int limit){
    return new Predicate<Records>() {
        int sum = 0;
        @Override
        public boolean test (Records records){
            sum = sum + records.getCount();
            return sum <= limit;
        }
    };
}

然后像这样使用它：

List<Records> limitedResult = recordList.stream().filter(limitRecordPredicate(limit)).collect(Collectors.toList());
// 对limitedResult进行操作
System.out.println(limitedResult);

输出：

[Records[recordID=100, count=10], Records[recordID=501, count=20], Records[recordID=302, count=5]]

public static void main(String[] args) {
        int limit = 35;
        List<Records> recordList = new ArrayList<>();
        recordList.add(new Records(100, 10));
        recordList.add(new Records(501, 20));
        recordList.add(new Records(302, 5));
        recordList.add(new Records(405, 2));
        recordList.add(new Records(918, 8));

        List<Records> limitedResult = recordList.stream().filter(new Predicate<Records>() {
            int sum = 0;
            @Override
            public boolean test(Records records) {
                sum=sum+records.getCount();
                return sum <= limit;
            }
        }).collect(Collectors.toList());
        //do what do you want with limitedResult
        System.out.println(limitedResult);
    }

    //Reusable predicate
    public static Predicate<Records> limitRecordPredicate(int limit){
        return new Predicate<Records>() {
            int sum = 0;
            @Override
            public boolean test (Records records){
                sum = sum + records.getCount();
                return sum <= limit;
            }
        };
    }

List<Records> limitedResult = recordList.stream().filter(limitRecordPredicate(limit)).collect(Collectors.toList());
        //do what do you want with limitedResult
        System.out.println(limitedResult);

[Records[recordID=100, count=10], Records[recordID=501, count=20], Records[recordID=302, count=5]]