I need an efficient way of removing items from list. If some condition happens, I need to remove first 'n' elements from a list. Can some one suggest the best way to do this? Please keep in mind: performance is a factor for me, so I need a faster way than itterating. Thanks.
I'm thinking of a way through which the 'n'th item can be made as the starting of the list so that the 0-n items will get garbage collected. Is it possible?
create subList()
Returns a view of the portion of this list between fromIndex, inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the returned list is empty.) The returned list is backed by this list, so changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations supported by this list.
Check implementation of this method and make some tests to determine performance
Jigar Joshi's answer is already contains the solution you need. I wanted to add some other stuff. Calling clear() on the sublist will handle your work, I guess. But it might be using
iteration in the background, I'm not sure. Example script for your use:
ArrayList<Integer> list = new ArrayList<Integer>();
ArrayList<Integer> subList = (ArrayList<Integer>) list.subList(0, 9);
subList.clear();
A single line solution is:
list.subList(n, m).clear();
Removes m - n elements from the list starting at index n stopping at index m - 1.
You can use ArrayList.removeRange(int fromIndex, int toIndex) .
Quoting the documentation:
Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive. Shifts any succeeding elements to the left (reduces their index). This call shortens the list by (toIndex - fromIndex) elements. (If toIndex==fromIndex, this operation has no effect.)
If performance is key for you, then I'm not sure using built-in functions from ArrayList is the way to go. I doubt they run faster than O(n) and sadly Java documentation says nothing about that. Maybe you should look into some custom made structures like a Rope.
/**
* @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
consider using Skip Lists, that will give you good performance if you will make number of dropped items aliquot to interval
it is not possible to omit iterations at all, but it is possible to reduce number of iterations or even make it "constant"
