从性能的角度来看，对于满足以下描述的要求，按照业务逻辑迭代列表的最佳方法是什么

Question

I have a list of entity. these are the response from db. I have another list of long. In the list of entity, each entity object has a filed called id. Those id will always be in ascending order.I need to traverse the entity list as per the order given through the list of long. Also I need to maintain another list of response object which will have few more fields than what we have in the entity list. I can not use transient also. The code below will give you an idea.

public List<ResponseObject> convert(List<EntityObject> entityList, List<Long> orderedIdList) {

    List<ResponseObject> responseList = new ArrayList<>();
    for (EntityObject object : entityList) {
        ResponseObject responseObject = new ResponseObject();
        responseObject.someSettermethod(object.someGettermethod());
        /* other setters in responseObject which are not present in the entity object */
        responseObject.otherSetters("some value"); 
        responseList.add(responseObject);
    };
    return sortInOrder(responseList, orderedIdList);
}

private List<ResponseObject> sortInOrder(List<ResponseObject> responseList,List<Long> orderedIdList) {
    List<ResponseObject> finalList = new ArrayList<>();
     for(Long id : orderedIdList){
         for(ResponseObject response : responseList){
             if(response.getId().equals(id)){
                 finalList.add(response);
             }
         }
     }
    return finalList;
}

This is how it has been implemented for now. I would like to know if there is any better approach to enhance the performance to achieve the same output.

Answer 1

If these lists aren't huge (like in many many thousands of entries), I wouldn't worry about performance. It's reasonable as it is and as long as you don't fail any specific performance requirements you shouldn't optimize your code for performance anyway. You could on the other hand optimize your code for readability

• by using a comparator to sort your list
• by using the streams API to reduce the depth of your methods.

The comparator could be constructed using the ordering list and then comparing the indices of the ids from your resultList.

The comparator could look similar to this one:

private static class IndexComparator implements Comparator<Long> {
    private final List<Long> order;

    private IndexComparator(List<Long> order) {
        this.order = order;
    }

    @Override
    public int compare(Long id1, Long id2) {
        return Comparator.comparingLong(order::indexOf).compare(id1, id2);
    }
}

Answer 2

The sortInOrder method can be done faster than O(N^2):

Assuming, Ids are unique (let me know if its a wrong assumption):

Idea:

1. Create a map of Id to responseObject by iterating over the response list O(n).
2. Iterate over orderedIdList and check for id in map, if the id exists, add the value to response Object.

private List<ResponseObject> sortInOrder(List<ResponseObject> responseList,List<Long> orderedIdList) {
    List<ResponseObject> finalList = new ArrayList<>();
    Map<Long, ResponseObject> map = responseList.stream().collect(Collectors.toMap(ResponseObject::getId, respObj -> respObj));
    for(Long id : orderedList) {
      if(map.containsKey(id)) {
         finalList.add(map.get(id));
      }
    }
    return finalList;
}

Answer 3

If you use map instead of a list like below, you can do it with complexity O(n) instead of O(n2)

public List<ResponseObject> convert(List<EntityObject> entityList, List<Long> orderedIdList) {

        Map<Long, ResponseObject> responseMap = new HashMap<Long, ResponseObject>();
        for (EntityObject object : entityList) {
            ResponseObject responseObject = new ResponseObject();
            responseObject.someSettermethod(object.someGettermethod());
            /* other setters in responseObject which are not present in the entity object */
            responseObject.otherSetters("some value");
            responseMap.put(responseObject.getId(), responseObject);
        };
        return sortInOrder(responseMap, orderedIdList);
    }

    private List<ResponseObject> sortInOrder( Map<Long, ResponseObject> responseMap, List<Long> orderedIdList) {
        List<ResponseObject> finalList = new ArrayList<>();
        for(Long id : orderedIdList){
            finalList.add(responseMap.get(id));
        }
        return finalList;
    }