28

我需要一种从列表中删除项目的有效方法。如果发生某种情况，我需要从列表中删除前 'n' 个元素。有人可以建议最好的方法吗？请记住：性能对我来说是一个因素，所以我需要一种比迭代更快的方法。谢谢。

我正在考虑一种方法，可以将第 n 个项目作为列表的开头，这样 0-n 项目就会被垃圾收集。可能吗？

4

8 回答 8

22

创造subList()

返回此列表在 fromIndex（包括）和 toIndex（不包括）之间部分的视图。（如果 fromIndex 和 toIndex 相等，则返回列表为空。）返回列表由此列表支持，因此返回列表中的更改会反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。

检查此方法的实现并进行一些测试以确定性能

于 2012-09-17T09:17:16.107 回答
11

Jigar Joshi 的答案已经包含您需要的解决方案。我想添加一些其他的东西。clear()我猜，调用子列表将处理你的工作。但它可能在后台使用迭代，我不确定。供您使用的示例脚本：

ArrayList<Integer> list = new ArrayList<Integer>();
ArrayList<Integer> subList = (ArrayList<Integer>) list.subList(0, 9);
subList.clear();
于 2012-09-17T09:23:07.953 回答
9

您可以使用ArrayList.removeRange(int fromIndex, int toIndex).

引用文档：

从此列表中删除索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。将任何后续元素向左移动（减少它们的索引）。此调用通过 (toIndex - fromIndex) 元素缩短列表。（如果toIndex==fromIndex，则此操作无效。）

于 2012-09-17T09:18:24.073 回答
5

如果性能是您的关键，那么我不确定使用 ArrayList 中的内置函数是否可行。我怀疑它们的运行速度比 O(n) 快，遗憾的是 Java 文档对此只字未提。也许您应该研究一些定制结构，例如Rope。

于 2012-09-17T09:24:53.393 回答
4

单行解决方案是：

 list.subList(n, m).clear();

从列表中删除m - n从 index 开始的元素，在 index 处n停止m - 1。

于 2020-05-29T21:49:31.733 回答
3

如果经常修改列表，为什么不使用 LinkedList 类呢？

如果使用 ArrayList 类，则在删除项目时，数组必须始终移动。

于 2012-09-17T09:26:34.953 回答
3

kotlin 扩展

/**
 * @param length remove index [0..length)
 */
fun <E> MutableList<E>.removeFirst(length: Int): MutableList<E> {
    if (length in 1..size) {
        subList(0, length).clear()
    }
    return this
}

/**
 * @param length remove index [(size - length)..size)
 */
fun <E> MutableList<E>.removeLast(length: Int): MutableList<E> {
    if (length in 1..size) {
        subList(size - length, size).clear()
    }
    return this
}

测试

package hello                      //  可选的包头

/**
 * @param length remove index [0..length)
 */
fun <E> MutableList<E>.removeFirst(length: Int): MutableList<E> {
    if (length in 1..size) {
        subList(0, length).clear()
    }
    return this
}

/**
 * @param length remove index [(size - length)..size)
 */
fun <E> MutableList<E>.removeLast(length: Int): MutableList<E> {
    if (length in 1..size) {
        subList(size - length, size).clear()
    }
    return this
}

fun main(args: Array<String>) {    // 包级可见的函数，接受一个字符串数组作为参数
   println("Hello World!")         // 分号可以省略

   val list = mutableListOf<String>("0","1","2","3","4","5","6","7")

    println(list)
    list.removeFirst(2)
    println(list)
    list.removeLast(2)
    println(list)

}

Hello World!
[0, 1, 2, 3, 4, 5, 6, 7]
[2, 3, 4, 5, 6, 7]
[2, 3, 4, 5]

参考

https://www.cnblogs.com/gaojing/archive/2012/06/17/java-list-sublist-caution.html

于 2018-08-11T07:59:48.890 回答
0

考虑使用Skip Lists，如果您将丢弃的项目数量等分到间隔，这将为您提供良好的性能

根本不可能省略迭代，但可以减少迭代次数甚至使其“恒定”

于 2012-09-17T09:21:37.483 回答