将普通的旧“for循环”转换为Java 8“forEach”

Question

见下文，我正在使用旧的 for 循环和如此多的 if 条件，我需要您的支持才能将其转换为 Java 8 forEach。我很无力解决这个问题。

在这里，我使用旧的 for 循环迭代订单对象，一次将 500 条数据发送到第三方服务器。 因为第三方服务器当时只允许 1500 行数据。所以我根据限制 1500 拆分列表。

这只是我的独立课程。我的意图是将旧的 for 循环转换为 java 8 流。

Answer 1

在这种情况下，我建议不要使用 Streams 选项，因为您想要的基本上与“flatMap”相反，即取一个 X 流并返回一个 Y 流，每个流都由几个 X。

在这个独立的示例中，chunkList 函数将列表“拆分”为块，而不进行复制（因为它只使用 subList），然后您的代码可以处理它，与分块代码分开 - 这可能进入sendRequest 函数，如果大小对于单个请求来说太大，我只是通过抛出来模拟它。我认为这充分代表了您的原始问题，但如果不是，请告诉我。

同样，您基本上可以“忽略”我的 Orders 和 repo_findAll 实现，它们基本上是为了使示例独立且可测试的模拟。

import java.util.List;

public class App 
{
    /** Your request size limit */
    private static final int MAX_REQ_SIZE = 500;

    /** Dummy representing your code that makes the HttpRequest. */
    public static void sendRequest(List<Orders> data) {
        if (data.size() > MAX_REQ_SIZE)
            throw new IllegalArgumentException("Invalid request size");
        System.out.println("Sending request of size " + data.size());
    }

    /** Possibility without Stream shenanigans. This function just creates a list of sub-lists of its argument,
     * each with a size &le; the given chunk size. The returned value will:<ul>
     * <li>Be non-null, with maybe 0 elements if the original list is empty.</li>
     * <li>Have elements of size chunkSize for every element except the last</li>
     * <li>Ultimately contain just references to indices in the original list, in the same order</li>
     * </ul>
     */
    public static List<List<Orders>> chunkList(List<Orders> orig, final int chunkSize) {
        if (chunkSize <= 0)
            throw new IllegalArgumentException();
        final List<List<Orders>> ret = new java.util.ArrayList<>();
        int begin = 0;
        for (; begin + chunkSize <= orig.size(); begin += chunkSize) {
            ret.add(orig.subList(begin, begin + chunkSize));
        }
        if (begin < orig.size()) {
            ret.add(orig.subList(begin, orig.size()));
        }
        return ret;
    }
    
    public static void main( String[] args )
    {
        // Your original dataset
        final List<Orders> data = repo_findAll();

        // The resulting operation
        for (List<Orders> curChunk : chunkList(data, MAX_REQ_SIZE)) {
            // You could place exception handling here to retry a chunk if it fails, etc
            sendRequest(curChunk);
        }
    }

    
    /** Dummy data class */
    private static class Orders {
        public final int number;
        public Orders(int number) {
            this.number = number;
        }
        @Override public String toString() {
            return "Order #" + number;
        }
    }
    /** Dummy representing your orders-generating function. This one makes a list of random size ~0.5-3 times the max request size, per sizesRnd below */
    static List<Orders> repo_findAll() {
        final int genSize = sizesRnd.nextInt();
        return java.util.stream.IntStream.range(1,genSize+1)
                .mapToObj(Orders::new).collect(java.util.stream.Collectors.toList());
    }
    private static final java.util.PrimitiveIterator.OfInt sizesRnd = new java.util.Random().ints(MAX_REQ_SIZE/2, MAX_REQ_SIZE*3+20).iterator();
}

Answer 2

如果我理解您的问题，您正在尝试将一个列表拆分为几个给定大小的子列表。我不会在迭代期间确定子列表，而是事先执行此操作，然后对子列表执行相同的进一步处理，即

1. 从您的订单列表List<Order> => List<List<Order>> 创建一个大小为 500 的订单列表列表
2. 遍历上述列表并一次发送一个列表的请求

例子

List<Orders> order = (List<Orders>) repo.findAll();
int chunkSize = 500;
AtomicInteger ai = new AtomicInteger();

Collection<List<Orders>> chunkedOrders = order.stream()
    .collect(Collectors.groupingBy(item -> ai.getAndIncrement() / chunkSize))
    .values();

//then the rest of your logic to send the requests
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);

chunkedOrders.forEach(chunk -> {    
    HttpEntity<List<Orders>> requestEntity = new HttpEntity<List<Orders>>(chunk, headers);
    RestTemplate restTemplate = new RestTemplate();
    System.out.println("Sending" + " " + chunk.size() + " " + "order data");
    sendToCarwings(restTemplate, requestEntity);
    System.out.println("Successfully sent" + " " + chunk.size() + " " + "order data");
 });

Answer 3

循环改变了 minLimit 和 maxLimit，所以 forEach 是不够的。

但您可以按如下方式改进循环：

    final int fixed = 500;
    int minLimit = 0;
    int maxLimit;
    for (maxLimit = fixed; maxLimit <= order.size(); maxLimit += fixed) {
            List<Orders> orderSubList = order.subList(minLimit, maxLimit);
            HttpEntity<List<Orders>> requestEntity = new HttpEntity<List<Orders>>(orderSubList, headers);
            RestTemplate restTemplate = new RestTemplate();
            System.out.println("Sending" + " " + minLimit + " " + "to" + " " + maxLimit + " " + "order data");
            sendToCarwings(restTemplate, requestEntity);
            System.out
                    .println("Successfully sent" + " " + minLimit + " " + "to" + " "+maxLimit + " " + "order data");
            minLimit = maxLimit;
    }

以不同的方式处理订单列表可能更有效；内存使用等。