好的，现在是对所提议方法的测试结果的时候了。这是我测试过的方法（每种方法的名称也是我的来源中的类名）：
-
NaiveRemoveManyPerformer - ArrayList 带有迭代器和删除 - 我的问题中给出的第一个和幼稚的实现。
-
BetterNaiveRemoveManyPerformer - ArrayList 向后迭代并从头到尾移除。
-
LinkedRemoveManyPerformer - 幼稚的迭代器和删除，但在 LinkedList 上工作。缺点：仅适用于LinkedList。
-
CreateNewRemoveManyPerformer - ArrayList 作为副本制作（仅添加保留元素），使用迭代器遍历输入 ArrayList。
-
SmartCreateNewRemoveManyPerformer - 更好 CreateNewRemoveManyPerformer - 结果 ArrayList 的初始大小（容量）设置为最终列表大小。缺点：启动时必须知道列表的最终大小。
-
FasterSmartCreateNewRemoveManyPerformer - 更好 (?) SmartCreateNewRemoveManyPerformer - 使用项目索引 (items.get(idx)) 而不是迭代器。
-
MagicRemoveManyPerformer - 适用于ArrayList 的原地工作（无列表副本），并从列表末尾的项目开始压缩洞（删除的项目）。缺点：这种方法会改变列表中项目的顺序。
-
ForwardInPlaceRemoveManyPerformer - 适用于 ArrayList - 移动保留项目以填充孔，最后返回 subList（没有最终删除或清除）。
-
GuavaArrayListRemoveManyPerformer - Google Guava Iterables.removeIf 用于 ArrayList - 与 ForwardInPlaceRemoveManyPerformer 几乎相同，但最终删除列表末尾的项目。
本答案末尾给出了完整的源代码。
使用不同的列表大小（从 10,000 项到 10,000,000 项）和不同的删除因素（指定必须从列表中删除多少项）执行的测试。
正如我在 cmets 中发布的其他答案一样 - 我认为将项目从 ArrayList 复制到第二个 ArrayList 将比迭代 LinkedList 并仅删除项目要快。 Sun 的 Java 文档说，与 LinkedList 实现相比，ArrayList 的常数因子较低，但令人惊讶的是，我的问题并非如此。
在实践中LinkedList 简单的迭代和删除在大多数情况下具有最佳性能（这种方法在LinkedRemoveManyPerformer 中实现）。通常只有MagicRemoveManyPerformer 的性能与LinkedRemoveManyPerformer 相当，其他方法明显慢得多。 Google Guava GuavaArrayListRemoveManyPerformer 比手工制作的类似代码慢（因为我的代码不会删除列表末尾不必要的项目）。
从 1,000,000 个源项目中删除 500,000 个项目的示例结果：
-
NaiveRemoveManyPerformer：未进行测试 - 我不是那么有耐心，但它的表现比 BetterNaiveRemoveManyPerformer 差。
-
BetterNaiveRemoveManyPerformer: 226080 毫秒
-
LinkedRemoveManyPerformer：69 毫微秒
-
CreateNewRemoveManyPerformer: 246 毫微秒
-
SmartCreateNewRemoveManyPerformer: 112 毫微秒
-
FasterSmartCreateNewRemoveManyPerformer: 202 毫微秒
-
MagicRemoveManyPerformer: 74 毫微秒
-
ForwardInPlaceRemoveManyPerformer: 69 毫微秒
-
GuavaArrayListRemoveManyPerformer: 118 毫微秒
从 1,000,000 个源项目中删除 1 个项目的示例结果（第一个项目被删除）：
- BetterNaiveRemoveManyPerformer：34 毫秒
- LinkedRemoveManyPerformer：41 毫秒
- CreateNewRemoveManyPerformer：253 毫（秒）
- SmartCreateNewRemoveManyPerformer：108 毫微秒
- FasterSmartCreateNewRemoveManyPerformer：71 毫秒
- MagicRemoveManyPerformer：43 毫秒
- ForwardInPlaceRemoveManyPerformer：73 毫秒
- GuavaArrayListRemoveManyPerformer：78 毫（秒）
从 1,000,000 个源项目中删除 333,334 个项目的示例结果：
- BetterNaiveRemoveManyPerformer：253206 毫秒
- LinkedRemoveManyPerformer：69 毫微秒
- CreateNewRemoveManyPerformer：245 毫秒
- SmartCreateNewRemoveManyPerformer：111 毫（秒）
- FasterSmartCreateNewRemoveManyPerformer：203 毫秒
- MagicRemoveManyPerformer：69 毫秒
- ForwardInPlaceRemoveManyPerformer：72 毫秒
- GuavaArrayListRemoveManyPerformer：102 毫（秒）
从 1,000,000 个源项中删除 1,000,000 个（全部）项的示例结果（所有项均已删除，但通过逐一处理，如果您先验地知道要删除所有项，则应简单地清除列表）：
- BetterNaiveRemoveManyPerformer：58 毫微秒
- LinkedRemoveManyPerformer：88 毫秒
- CreateNewRemoveManyPerformer：95 毫微秒
- SmartCreateNewRemoveManyPerformer：91 毫（秒）
- FasterSmartCreateNewRemoveManyPerformer：48 毫微秒
- MagicRemoveManyPerformer：61 毫秒
- ForwardInPlaceRemoveManyPerformer：49 毫秒
- GuavaArrayListRemoveManyPerformer：133 毫（秒）
我的最终结论：使用混合方法 - 如果处理 LinkedList - 简单的迭代和删除是最好的，如果处理 ArrayList - 这取决于项目顺序是否重要 - 然后使用 ForwardInPlaceRemoveManyPerformer，如果项目顺序可能会更改 - 最佳选择是MagicRemoveManyPerformer。如果删除因素是先验已知的（您知道将删除多少项与保留多少项），则可以使用更多条件来选择在特定情况下表现更好的方法。但是已知的删除因素并不常见...... Google Guava Iterables.removeIf 就是这样一种混合解决方案，但假设略有不同（必须更改原始列表，无法创建新列表并且项目顺序始终很重要） - 这些是最常见的假设所以removeIf 是大多数现实生活中的最佳选择。
还要注意，所有好的方法（天真不好！）都足够好 - 它们中的任何一种在实际应用中都应该做得很好，但必须避免天真的方法。
最后 - 我的测试源代码。
package WildWezyrListRemovalTesting;
import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class RemoveManyFromList {
public static abstract class BaseRemoveManyPerformer {
protected String performerName() {
return getClass().getSimpleName();
}
protected void info(String msg) {
System.out.println(performerName() + ": " + msg);
}
protected void populateList(List<Integer> items, int itemCnt) {
for (int i = 0; i < itemCnt; i++) {
items.add(i);
}
}
protected boolean mustRemoveItem(Integer itemVal, int itemIdx, int removeFactor) {
if (removeFactor == 0) {
return false;
}
return itemIdx % removeFactor == 0;
}
protected abstract List<Integer> removeItems(List<Integer> items, int removeFactor);
protected abstract List<Integer> createInitialList();
public void testMe(int itemCnt, int removeFactor) {
List<Integer> items = createInitialList();
populateList(items, itemCnt);
long startMillis = System.currentTimeMillis();
items = removeItems(items, removeFactor);
long endMillis = System.currentTimeMillis();
int chksum = 0;
for (Integer item : items) {
chksum += item;
}
info("removing took " + (endMillis - startMillis)
+ " milli(s), itemCnt=" + itemCnt
+ ", removed items: " + (itemCnt - items.size())
+ ", remaining items: " + items.size()
+ ", checksum: " + chksum);
}
}
private List<BaseRemoveManyPerformer> rmps =
new ArrayList<BaseRemoveManyPerformer>();
public void addPerformer(BaseRemoveManyPerformer rmp) {
rmps.add(rmp);
}
private Runtime runtime = Runtime.getRuntime();
private void runGc() {
for (int i = 0; i < 5; i++) {
runtime.gc();
}
}
public void testAll(int itemCnt, int removeFactor) {
runGc();
for (BaseRemoveManyPerformer rmp : rmps) {
rmp.testMe(itemCnt, removeFactor);
}
runGc();
System.out.println("\n--------------------------\n");
}
public static class NaiveRemoveManyPerformer
extends BaseRemoveManyPerformer {
@Override
public List<Integer> removeItems(List<Integer> items, int removeFactor) {
if (items.size() > 300000 && items instanceof ArrayList) {
info("this removeItems is too slow, returning without processing");
return items;
}
int i = 0;
Iterator<Integer> iter = items.iterator();
while (iter.hasNext()) {
Integer item = iter.next();
if (mustRemoveItem(item, i, removeFactor)) {
iter.remove();
}
i++;
}
return items;
}
@Override
public List<Integer> createInitialList() {
return new ArrayList<Integer>();
}
}
public static class BetterNaiveRemoveManyPerformer
extends NaiveRemoveManyPerformer {
@Override
public List<Integer> removeItems(List<Integer> items, int removeFactor) {
// if (items.size() > 300000 && items instanceof ArrayList) {
// info("this removeItems is too slow, returning without processing");
// return items;
// }
for (int i = items.size(); --i >= 0;) {
Integer item = items.get(i);
if (mustRemoveItem(item, i, removeFactor)) {
items.remove(i);
}
}
return items;
}
}
public static class LinkedRemoveManyPerformer
extends NaiveRemoveManyPerformer {
@Override
public List<Integer> createInitialList() {
return new LinkedList<Integer>();
}
}
public static class CreateNewRemoveManyPerformer
extends NaiveRemoveManyPerformer {
@Override
public List<Integer> removeItems(List<Integer> items, int removeFactor) {
List<Integer> res = createResultList(items, removeFactor);
int i = 0;
for (Integer item : items) {
if (mustRemoveItem(item, i, removeFactor)) {
// no-op
} else {
res.add(item);
}
i++;
}
return res;
}
protected List<Integer> createResultList(List<Integer> items, int removeFactor) {
return new ArrayList<Integer>();
}
}
public static class SmartCreateNewRemoveManyPerformer
extends CreateNewRemoveManyPerformer {
@Override
protected List<Integer> createResultList(List<Integer> items, int removeFactor) {
int newCapacity = removeFactor == 0 ? items.size()
: (int) (items.size() * (removeFactor - 1L) / removeFactor + 1);
//System.out.println("newCapacity=" + newCapacity);
return new ArrayList<Integer>(newCapacity);
}
}
public static class FasterSmartCreateNewRemoveManyPerformer
extends SmartCreateNewRemoveManyPerformer {
@Override
public List<Integer> removeItems(List<Integer> items, int removeFactor) {
List<Integer> res = createResultList(items, removeFactor);
for (int i = 0; i < items.size(); i++) {
Integer item = items.get(i);
if (mustRemoveItem(item, i, removeFactor)) {
// no-op
} else {
res.add(item);
}
}
return res;
}
}
public static class ForwardInPlaceRemoveManyPerformer
extends NaiveRemoveManyPerformer {
@Override
public List<Integer> removeItems(List<Integer> items, int removeFactor) {
int j = 0; // destination idx
for (int i = 0; i < items.size(); i++) {
Integer item = items.get(i);
if (mustRemoveItem(item, i, removeFactor)) {
// no-op
} else {
if (j < i) {
items.set(j, item);
}
j++;
}
}
return items.subList(0, j);
}
}
public static class MagicRemoveManyPerformer
extends NaiveRemoveManyPerformer {
@Override
public List<Integer> removeItems(List<Integer> items, int removeFactor) {
for (int i = 0; i < items.size(); i++) {
if (mustRemoveItem(items.get(i), i, removeFactor)) {
Integer retainedItem = removeSomeFromEnd(items, removeFactor, i);
if (retainedItem == null) {
items.remove(i);
break;
}
items.set(i, retainedItem);
}
}
return items;
}
private Integer removeSomeFromEnd(List<Integer> items, int removeFactor, int lowerBound) {
for (int i = items.size(); --i > lowerBound;) {
Integer item = items.get(i);
items.remove(i);
if (!mustRemoveItem(item, i, removeFactor)) {
return item;
}
}
return null;
}
}
public static class GuavaArrayListRemoveManyPerformer
extends BaseRemoveManyPerformer {
@Override
protected List<Integer> removeItems(List<Integer> items, final int removeFactor) {
Iterables.removeIf(items, new Predicate<Integer>() {
public boolean apply(Integer input) {
return mustRemoveItem(input, input, removeFactor);
}
});
return items;
}
@Override
protected List<Integer> createInitialList() {
return new ArrayList<Integer>();
}
}
public void testForOneItemCnt(int itemCnt) {
testAll(itemCnt, 0);
testAll(itemCnt, itemCnt);
testAll(itemCnt, itemCnt - 1);
testAll(itemCnt, 3);
testAll(itemCnt, 2);
testAll(itemCnt, 1);
}
public static void main(String[] args) {
RemoveManyFromList t = new RemoveManyFromList();
t.addPerformer(new NaiveRemoveManyPerformer());
t.addPerformer(new BetterNaiveRemoveManyPerformer());
t.addPerformer(new LinkedRemoveManyPerformer());
t.addPerformer(new CreateNewRemoveManyPerformer());
t.addPerformer(new SmartCreateNewRemoveManyPerformer());
t.addPerformer(new FasterSmartCreateNewRemoveManyPerformer());
t.addPerformer(new MagicRemoveManyPerformer());
t.addPerformer(new ForwardInPlaceRemoveManyPerformer());
t.addPerformer(new GuavaArrayListRemoveManyPerformer());
t.testForOneItemCnt(1000);
t.testForOneItemCnt(10000);
t.testForOneItemCnt(100000);
t.testForOneItemCnt(200000);
t.testForOneItemCnt(300000);
t.testForOneItemCnt(500000);
t.testForOneItemCnt(1000000);
t.testForOneItemCnt(10000000);
}
}