Java 将列表转换为具有特定顺序的ArrayList

编写此代码的最佳方法是：

objectsList不是空列表。包含许多对象。这只是为了说明类型

    List<ObjectType> objectsList= Collections.EMPTY_LIST;

    ArrayList<RelatedModule> arrayWithOrder = new ArrayList<>();

    Map<Integer, RelatedModule> mappedObjects= new HashMap<>();

    objectsList.forEach(o ->
            mappedObjects.put(o.getOrder(),
                    new Dto(o.getFirstName(),
                            o.getLastName()))
    );

    for (int i = 0; i < objectsList.size(); i++) {
        arrayWithOrder.add(mappedObjects.get(i));
    }

List objectsList=Collections.EMPTY\u List；
ArrayList arrayWithOrder=新的ArrayList（）；
Map mappedObjects=新建HashMap（）；
objectsList.forEach（o->
mappedObjects.put（o.getOrder（），
新的Dto（o.getFirstName（），
o、 getLastName（））
);
对于（int i=0；i

您可以使用

树形图，但是，除非有多个对象具有相同的顺序，并且目的是只保留最后一个对象，否则您可以简单地对列表进行排序，然后对其进行转换：

List<RelatedModule> arrayWithOrder = 
    objectsList.stream()
               .sorted(Comparator.comparingInt(ObjectType::getOrder))
               .map(o -> new RelatedModule(o.getFirstName(), o.getLastName()))
               .collect(Collectors.toList());

List arrayWithOrder=
objectsList.stream（）
.sorted（Comparator.comparingInt（ObjectType:：getOrder））
.map（o->new RelatedModule（o.getFirstName（），o.getLastName（））
.collect（Collectors.toList（））；
您可以使用
树形图，但是，除非有多个对象具有相同的顺序，并且目的是只保留最后一个对象，否则您可以简单地对列表进行排序，然后对其进行转换：

List<RelatedModule> arrayWithOrder = 
    objectsList.stream()
               .sorted(Comparator.comparingInt(ObjectType::getOrder))
               .map(o -> new RelatedModule(o.getFirstName(), o.getLastName()))
               .collect(Collectors.toList());

List arrayWithOrder=
objectsList.stream（）
.sorted（Comparator.comparingInt（ObjectType:：getOrder））
.map（o->new RelatedModule（o.getFirstName（），o.getLastName（））
.collect（Collectors.toList（））；
使用
sorted
或
TreeMap
等的问题在于，它在
O（n log n）
时间中计算
O（n）
时间中可以计算的内容。在您的情况下，您不需要排序，因为您已经知道顺序-它由
order
属性决定

最快的解决方案如下：

RelatedModule[] arrayWithOrder = new RelatedModule[objectsList.size()];
for (ObjectType o : objectsList)
    arrayWithOrder[o.getOrder()] = new Dto(o.getFirstName(), o.getLastName());

然后，您可能希望将结果复制到新的
ArrayList

您的原始代码具有最佳的时间复杂度，但您可以做的一个改进是在
forEach
中使用
collect
调用，而不是
put
或
add
，使用
sorted
或
树映射的麻烦在于它在
O（n log n）中计算
time在
O（n）
time中可以计算的内容。在您的情况下，您不需要排序，因为您已经知道顺序-它由
order
属性决定

最快的解决方案如下：

RelatedModule[] arrayWithOrder = new RelatedModule[objectsList.size()];
for (ObjectType o : objectsList)
    arrayWithOrder[o.getOrder()] = new Dto(o.getFirstName(), o.getLastName());

然后，您可能希望将结果复制到新的
ArrayList

您的原始代码具有最佳的时间复杂度，但是您可以做的一个改进是在
forEach
中使用
collect
调用，而不是
put
或
add
，尝试使用
TreeMap
而不是
HashMap
。将
Comparable
接口实现到
ObjectType
类，然后使用
TreeMap
，而不是
HashMap
@SungJinSteveYoo实现Comparable是无用的：映射的键是整数。@如果是空指针，那么它们的顺序就错了。它们需要按顺序排序。这张地图不需要。它只用于重新排列它们。（并消除重复项，如果有的话。）说到哪一项，会有重复项？这是你需要注意的。哈希映射将消除它们。我有种感觉，你不希望有任何复制品，尽管如此。尝试使用
TreeMap
而不是
HashMap
。将
Comparable
接口实现到
ObjectType
类，然后使用
TreeMap
而不是
HashMap
@sungjinstevyoo实现Comparable是没有用的：映射的键是整数。@如果是空指针，那么它们就错了顺序它们需要按顺序排序。这张地图不需要。它只用于重新排列它们。（并消除重复项，如果有的话。）说到哪一项，会有重复项？这是你需要注意的。哈希映射将消除它们。不过，我有种感觉，你不希望有任何重复。