Question

Assume I am running either of the code snippets below for a list of 1000 Event entries (in allEventsToAggregate). Would I see a performance improvement in the first implementation if the events in allEventsToAggregate are sorted by customerId, with each customer having roughly 3 events? This is essentially a question of string comparison vs. HashMap lookup performance.

Option 1:

Map<String, List<Event>> eventsByCust = new HashMap<String, List<Event>>();
List<Event> thisCustEntries;
String lastCust = null;
for (Event thisEvent : allEventsToAggregate) {
    if (!thisEvent.getCustomerId().equals(lastCust)) {
        thisCustEntries = eventsByCust.get(thisEvent.getCustomerId());
        if (thisCustEntries == null) {
            thisCustEntries = new ArrayList<Event>();
        }
    }
    thisCustEntries.add(thisEvent);
    eventsByCust.put(thisEvent.getCustomerId(), thisCustEntries);
    lastCust = thisEvent.getCustomerId();
}

Option 2:

Map<String, List<Event>> eventsByCust = new HashMap<String, List<Event>>();
for (Event thisEvent : allEventsToAggregate) {
    List<Event> thisCustEntries = eventsByCust.get(thisEvent.getCustomerId());
    if (thisCustEntries == null) {
        thisCustEntries = new ArrayList<Event>();
    }
    thisCustEntries.add(thisEvent);
}

Answer 1

Would I see a performance improvement

Almost certainly not. Unless this block represents a critical inner loop of your application, any marginal performance gains will almost certainly be unnoticeable.

Consequently, I would go with the second version of the code, as its a clearer expression of your intent and so will be easier to maintain (as well as being slightly less prone to subtle bugs in the first place). Maintainability almost certainly trumps making the application 0.001% faster.