通用列表元素操作方法：处理异常时遍历全量元素并抛出首个异常

Got it, let's walk through how to build this logic exactly as you described. Here's a practical, Java-based implementation that hits all your requirements:

Core Requirements Recap #

First, let's make sure we're aligned on what we need:

• Process every element in the input list, even if some throw exceptions
• Track the first encountered exception and throw it only after all elements are processed
• Output results don't depend on input order (so parallel processing is fair game here)

Implementation Code #

We'll use thread-safe collections and atomic references to handle both sequential and parallel processing safely:

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;

public class ResilientListProcessor<T, R> {

    public List<R> processElements(List<T> inputs, Function<T, R> elementProcessor) {
        // Thread-safe list for results (works with sequential/parallel processing)
        List<R> processedResults = new CopyOnWriteArrayList<>();
        // Atomic reference to safely capture the FIRST exception encountered
        AtomicReference<Throwable> firstThrownException = new AtomicReference<>();

        // Process each element - use parallelStream() for unordered processing
        inputs.parallelStream().forEach(input -> {
            try {
                R result = elementProcessor.apply(input);
                processedResults.add(result);
            } catch (Throwable t) {
                // Only set the exception if none has been recorded yet
                firstThrownException.compareAndSet(null, t);
            }
        });

        // After all elements are processed, throw the first exception if it exists
        if (firstThrownException.get() != null) {
            throw new RuntimeException(
                "Processing completed but encountered an error (first exception shown below)",
                firstThrownException.get()
            );
        }

        return processedResults;
    }
}

Key Details Explained #

• Thread-Safe Collections: CopyOnWriteArrayList ensures that even if we use parallel processing (via parallelStream()), we don't get race conditions when adding results. This also means the output order won't match the input order, which fits your requirement.
• Atomic Exception Tracking: AtomicReference guarantees that only the first exception is stored, even if multiple elements throw exceptions at the same time in parallel.
• Full Traversal: No matter how many exceptions are thrown, we'll loop through every element in the list before checking for exceptions to throw.

Usage Example #

Let's test this with a simple scenario where dividing by zero will throw an exception:

public class Main {
    public static void main(String[] args) {
        List<Integer> inputNumbers = List.of(5, 10, 0, 20, 2);
        ResilientListProcessor<Integer, Integer> processor = new ResilientListProcessor<>();

        try {
            List<Integer> results = processor.processElements(inputNumbers, num -> 100 / num);
            System.out.println("Processed results: " + results);
        } catch (RuntimeException e) {
            System.err.println("\nError during processing: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

What Happens Here: #

1. All elements are processed: 5→20, 10→10, 0→throws exception, 20→5, 2→50
2. The first exception (from the 0 element) is stored
3. After all processing is done, the exception is thrown
4. The results list will contain [20, 10, 5, 50] (order may vary due to parallel processing)

Additional Notes #

• If you don't need parallel processing, replace parallelStream().forEach() with a regular forEach() loop. You can even switch to a standard ArrayList for results in that case.
• If your element processor throws checked exceptions, you can either wrap them in a runtime exception (as shown) or create a custom functional interface that declares checked exceptions.
• To preserve result order (if you ever need to), just switch back to a sequential stream and use a regular ArrayList—but your requirement specifies order doesn't matter, so parallel is optimal for performance.

内容的提问来源于stack exchange，提问作者tb189