web-dev-qa-db-fra.com

Supprimer les premiers éléments 'n' de la liste sans effectuer d'itération

J'ai besoin d'un moyen efficace de supprimer des éléments de la liste. Si une condition survient, je dois supprimer les premiers éléments 'n' d'une liste. Quelqu'un peut-il suggérer le meilleur moyen de le faire? N'oubliez pas que la performance est un facteur pour moi. J'ai donc besoin d'un moyen plus rapide que de le parcourir. Merci.

Je pense à un moyen de créer le nième élément comme point de départ de la liste pour que les éléments 0-n soient récupérés. C'est possible?

javalist
15
Eldhose M Babu

Si les performances sont essentielles pour vous, je ne suis pas sûr d'utiliser les fonctions intégrées de ArrayList. Je doute qu'ils fonctionnent plus vite que O(n) et malheureusement, la documentation Java ne dit rien à ce sujet. Peut-être devriez-vous vous pencher sur des structures personnalisées comme un Corde .

5
tu_ru

créer subList()

Renvoie une vue de la partie de cette liste entre fromIndex, inclus, et toIndex, exclusif. (Si fromIndex et toIndex sont égaux, la liste renvoyée est vide.) La liste renvoyée est sauvegardée par cette liste. Par conséquent, les modifications apportées à la liste renvoyée sont reflétées dans cette liste, et inversement. La liste renvoyée prend en charge toutes les opérations de liste facultatives prises en charge par cette liste.

Vérifier la mise en œuvre de cette méthode et faire des tests pour déterminer les performances 

21
Jigar Joshi

Vous pouvez utiliser ArrayList.removeRange(int fromIndex, int toIndex).

Citer la documentation : 

Supprime de cette liste tous les éléments dont l'index est compris entre FromIndex, inclus, et toIndex, exclusive. Déplace les éléments Suivants vers la gauche (réduit leur index). Cet appel raccourcit la liste Par des éléments (toIndex - fromIndex). (Si toIndex == fromIndex, cette opération Est sans effet.)

9
Santosh

La réponse de Jigar Joshi est déjà contient la solution dont vous avez besoin. Je voulais ajouter d'autres choses. L'appel de clear() sur la sous-liste se chargera de votre travail, je suppose. Mais il se peut qu’il utilise l’itération En arrière-plan, je ne suis pas sûr. Exemple de script pour votre utilisation:

ArrayList<Integer> list = new ArrayList<Integer>();
ArrayList<Integer> subList = (ArrayList<Integer>) list.subList(0, 9);
subList.clear();
7
Juvanis

Si vous modifiez fréquemment la liste, pourquoi ne pas utiliser la classe LinkedList?

Si vous utilisez la classe ArrayList, lors de la suppression d'un élément, le tableau doit toujours être déplacé.

2
Daniel

pensez à utiliser Ignorer les listes , cela vous donnera de bonnes performances si vous voulez que le nombre d'éléments supprimés soit divisé en intervalles.

il n'est pas possible d'omettre des itérations, mais il est possible de réduire le nombre d'itérations ou même de le rendre "constant"

0
jdevelop

extensions de 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
}

tester

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]

référence

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

0
Michael Mao