從性能的角度來看，對於滿足以下描述的要求，按照業務邏輯迭代列表的最佳方法是什么

Question

我有實體清單。 這些是數據庫的響應。 我還有另一個清單。 在實體列表中，每個實體對象都有一個稱為id的文件。 這些id總是按升序排列。我需要按照long列表中給出的順序遍歷實體列表。 另外，我需要維護另一個響應對象列表，該列表將比實體列表中的字段多一些。 我也不能使用瞬態。 下面的代碼將給您一個想法。

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;
}

這是目前已實施的方式。 我想知道是否有更好的方法來增強性能以實現相同的輸出。

Answer 1

如果這些列表不是很大 （就像成千上萬的條目一樣），我將不必擔心性能。 這樣做是合理的，只要您不滿足任何特定的性能要求，就無論如何都不應針對性能優化代碼。 另一方面，您可以優化代碼以提高可讀性

• 通過使用比較器對列表進行排序
• 通過使用streams API來減少方法的深度。

可以使用排序列表構造比較器，然后從您的resultList中比較ID的索引。

比較器看起來可能與此類似：

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

sortInOrder方法可以比O（N ^ 2）更快地完成：

假設ID是唯一的（如果錯誤假設，請告知我）：

理念：

1. 通過遍歷響應列表O（n），創建一個ID到responseObject的映射。
2. 遍歷orderedIdList並檢查地圖中的id，如果該id存在，則將該值添加到響應對象。

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

如果使用map而不是下面的列表，則可以使用O（n）而不是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;
    }