收集Java方法中的错误，清空ArrayList与LinkedList

Question

I seem to create these two kind of methods occasionally:

// return null on errors, and append errors to 2nd param, otherwise return result
String fetchSomething(String parameter, List<String> errorMessagesOut);

// return empty list or null on no errors, otherwise list of errors
List<String> verifySomething(String parameter);

And then the code which calls these will join the error list with appropriate separator (such as simple comma, newline, HTML tags...), usually using Apache Commons Stringutils.join method. And in normal case there's no error, and list will be empty.

So, I started wondering about these two questions:

1. Do you see a problem with returning error message strings as list? If so, what is better alternative? (Not exceptions, that would be thrown by code which calls these methods, when that is wanted.)

2. Is new LinkedList() or new ArrayList(0) or new ArrayList() better for list which is expected to remain empty, and which should normally have only sequential iterator access when it is not empty?

---

EDIT: Example use case:

List<String> verifyParameters(JSONObject params) {
    List<String> ret = new ArrayList<String>(0);

    if (!verifyKey(params.get("key"))) 
        ret.add("Invalid key: " + key);

    if (!verifyAccess(params.get("user"), params.get("pass"))) 
        ret.add("Authentication error");

   return ret;
}

...

List<String> errors = verifyParameters(params);
if (!errors.isEmpty()) {

    connection.sendErrorListMessage(errors);
    logger.warn(StringUtils.join(errors, ", "));
    controlPanel.show("Errors: \n- " + StringUtils.join(errors, "\n- ") + '\n');
    throw new AbortException("invalid params); // or maybe return false/null;
}
// proceed with valid params

Usually handling of error list would not have all of those, it just tries to illustrate the point that error list is a list of messages meant for humans to see, independent of how it will be shown, and also not related to/useful for handling different errors differently.

Answer 1

I think it's fine to use a List for the Strings. I would be inclined to make a dedicated Result class at least for fetchSomthing and make it like this, especially if the errorMessagesOut passed is never anything except a new empty List:

Result result = fetchSomething(String parameter);
if (result.hasErrors()) {
    List<String> errors = result.getErrors();
} else {
    String fetched = result.getValue();
}

I would then also put any of the methods that process the error Strings on this class also so you could do something like:

String errorMessage = result.getErrorString();

This encapsulates the error data and the formatting of it within the one Class and means that in the case of no errors you don't need to create any List internally in your Result instance.

My above points are mostly about the code design. There is no point in trying micro-optimization without profiling and having benchmarks to compare to the results of any changes.

Answer 2

What are these errors for? Are you going to do some business decision off of the errors returned by a method? Otherwise, if the errors are just for logging, a simple Logging solution would suggest that the errors are logged as soon as they occur. I'm talking about those logger.debug("Error message"); .

Anyway, could you give us an example of what is done to this errors after they are returned?

One thing I point, though: It tends to be confusing if you're using the same array / list / collection for both processing results and for errors. It would also be confusing if your methods returned error lists (or empty/null lists in case of no error) as it would appear that the errors are the very result of executing your method.

Answer 3

There is nothing wrong in trying to collect all error information using a list. Using an ArrayList will work fine, no need to worry about that...

In case you know there are no errors you could return Collections.emptyList(); .

In general with Collections avoid returning both null or empty list. I always use empty list as does not break for loops.

Answer 4

Do you see a problem with returning error message strings as list? If so, what is better alternative?

No. There is nothing wrong in using a list if it solves your problem there.

Is new LinkedList() or new ArrayList(0) or new ArrayList() better for list which is expected to remain empty, and which should normally have only sequential iterator access when it is not empty?

Knowing about how many elements the list is going to store and instantiating the list with that capacity will not have any significant improvement in the performance:

Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.

You'll however save some memory with new ArrayList(0) if the list is most often empty as the size of list is initialized to 10 when no initial capacity is specified.