添加到列表时有没有办法避免循环？

Question

我想知道这样的代码：

List<String> list = new ArrayList<String>();
for(CustomObject co : objects) {
    list.add(co.getActualText());
}

它可以写成不同的吗？我的意思当然是在某些时候会有一个循环，但我想知道是否有我忽略的 API 使用

Answer 1

如果您使用 Java 8，则可以利用 Stream API：

List<String> list = objects.stream()
                           .map(CustomObject::getActualText)
                           .collect(Collectors.toList());

Answer 2

如果你有 Java 8，那么：

objects.forEach(item -> list.add(item.getActualText()));

虽然内部仍然是一个循环。

编辑一点题外话：IMO 这是最易读和最好的解决方案。为什么不直接使用你可能会问的 foreach。答案：因为这样集合选择了迭代项目的最佳方式。例如，ArrayList 不使用迭代器，因为它比你更清楚：

@Override
public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    @SuppressWarnings("unchecked")
    final E[] elementData = (E[]) this.elementData;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        action.accept(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

Answer 3

当然，Apache Commons 和 Guava 也提供了在不使用 Java 8 的情况下避免循环的方法。

普通CollectionUtils.collect:

CollectionUtils.collect(objects, Transformer.invokerTransformer("getActualText"), list);

番石榴Lists.transform:

List<String> list = Lists.transform(objects, 
    new Function<CustomObject, String>() { 
        public String apply(CustomObject co) {
            return co.getActualText();
        }
    }
);

Answer 4

虽然显然有点荒谬的建议：您可以通过递归添加循环来避免循环。

void add(List<? super String> receiver, CustomObject[] objects) {
  addRec(receiver, toAdd, 0, objects.length());
}

void addRec(List<? super String> receiver, CustomObject[] objects, int start, int end) {
  if (start + 1 == end) {
    receiver.add(objects[start].getActualText());
  } else if (start != end) {
    int mid = (start + end) / 2;
    addRec(receiver, objects, start, mid);
    addRec(receiver, objects, mid, end);
  }
}

Answer 5

如果您使用Eclipse Collections，您可以从 Java 8 开始编写以下代码：

MutableList<CustomObject> objects = ...
MutableList<String> result = objects.collect(CustomObject::getActualText);

在 Java 5 - 7 中，您可以通过 collect 方法使用表示 SAM 类型 Function 的匿名内部类。

MutableList<CustomObject> objects = ...
MutableList<String> result = objects.collect(new Function<CustomObject, String>() {
    public String valueOf(CustomObject object){
        return object.getActualText();
    }
});

注意：我是 Eclipse Collections 的提交者

Answer 6

在 Java 8 中使用流会更惯用，但如果您希望它更接近传统的基于循环的方法，您可以使用 forEach：

objects.forEach(co -> list.add(co.getActualText()) );

Answer 7

为了在相互未知的两种类型的列表之间复制一定范围的数据时获得非常好的效率，必须有一种机制，通过这种机制，“受信任”类型可以要求每个类型公开关联的后备数组使用一系列元素，然后使用批量复制操作将数据从一个移动到另一个。完全用 Java 编写这样一个类是可能的，方法是将 GetArraySource 方法传递给受信任的 ArraySource 类的构造函数，该对象可以用来请求与特定元素关联的支持数组（返回将包括支持数组和其中包含的元素范围）。想要复制的代码将调用GetArraySource，并将由此返回的ArraySource 传递给目标列表的CopyFromArraySource 方法，然后该方法可以要求ArraySource 将一个或多个项目范围复制到它自己的后备数组中（s )。

如果ArraySource 是Java 提供的一个类，并且Oracle 准确记录了它将如何处理它收到的数组，那么ArrayList 和String 之类的类型就有可能将它们的内容公开为@ 987654330@，或接受来自ArraySource 的外部数据，而不会将其数组不当暴露给任何可能滥用它的代码。

不幸的是，除非 Oracle 将这样的东西合并到 Java 发行版中，否则支持可能太少而无用。让源列表支持一个这样的类，目标支持另一个，以及想要复制操作的代码第三个是不好的。所有三个类都需要支持同一个特定的trusted-array-segment-copy-helper 类。