Comment tout supprimer d'une ArrayList en Java mais le premier élément

Vous pouvez utiliser

mapOverlays.subList(1, mapOverlays.size()).clear();

Pourquoi n'essayez-vous pas en arrière?

int size = itemizedOverlay.size();
for(int n=size-1;n>0;n--)
{
    mapOverlays.remove(n);
}

Je pense qu'il serait plus rapide de créer une nouvelle ArrayList avec juste le premier élément à l'intérieur. quelque chose comme :

E temp = mapOverlays.get(0);
mapOverlays = new ArrayList<E>().add(temp);

Simple.

mapOverlays = Collections.singletonList(mapOverlays.get(0));

Un ArrayList a des indices entiers de 0 à size() - 1. Vous pourriez faire:

int size = mapOverlays.size();
for(int n=1;n<size;n++)
{
    mapOverlays.remove(1);
}

Cela correspond probablement à ce que vous attendez de PHP. Cela fonctionne en supprimant continuellement le 1ème élément, qui change. Cependant, cela a de mauvaises performances, car le tableau interne doit constamment être déplacé vers le bas. Il est préférable d'utiliser clear(), ou aller dans l'ordre inverse.

, Il est trop mauvais removeRange est protégé, comme ce serait pratique pour ce type d'opération.

Je suppose que mapOverlays contient une référence ArrayList.

Si mapOverlays est déclaré comme un List ou ArrayList, puis mapOverlays.remove(n) va se référer à la remove(int) méthode qui supprime l'objet à un décalage. (So far So good ...)

Lorsque vous supprimez l'élément nth d'un tableau en utilisant remove(int), les éléments commençant à la position n + 1 et surtout sont abaissés d'un. Donc, ce que vous faites ne fonctionnera pas réellement dans la plupart des cas. (En fait, vous êtes susceptible de supprimer environ la moitié des éléments que vous souhaitez supprimer, puis obtenir un IndexOutOfBoundsException.)

, La meilleure solution est soit:

    for (int i = size - 1; i > 0; i--) {
        mapOverlays.remove(i);
    }

Ou

    tmp = mapOverlays.remove(0);
    mapOverlays.clear();
    mapOverlays.add(tmp);

(Notez que la première solution supprime toujours de la fin de la liste, évitant la nécessité de copier des éléments pour combler le trou laissé par l'élément supprimé. La performance différente est significative pour une grande ArrayList.)

Cependant, si mapOverlays est déclaré comme un Collection, remove(n) vont se lier à l' remove(<E>) surcharge qui supprime l'objet qui correspond à son argument. Selon le type déclaré, cela vous donnera soit une erreur de compilation, soit le int sera autoboxé en tant que Integer et vous (probablement) ne supprimerez rien. JE T'Ai EU!

Si vous utilisez une implémentation java.util.List au lieu d'un tableau, la taille du tableau diminue chaque fois que vous supprimez quelque chose et que l'élément n+1 remplace l'élément n. Ce code finira par aboutir à ArrayIndecOutOfBoundsException lorsque n devient plus grand que le dernier index de la liste.

Java a également un type de tableau et la taille de celui-ci ne peut pas être modifiée:

Object[] mapOverlay = //initialize the array here
int size = mapOverlay.length;
for(int n=1;n<size;n++)
{
    mapOverlay[n] = null;
}

Je ne connais pas PHP mais cela semble proche du comportement que vous recherchez. Cependant les implémentations de liste sont plus flexible et confortable que les tableaux.

EDIT: Voici un lien vers la Javadoc de List.remove(int): http://java.sun.com/javase/6/docs/api/java/util/List.html#remove%28int%29

Utiliser Google collections et Liste.limite http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/collect/Iterables.html#limit(java.lang.Iterable, int)

Utilisez une boucle while pour tout supprimer après le premier élément:

while (mapOverlays.size() > 1) {
    mapOverlays.remove(1);
}

EDIT (voir le commentaire d'Adam Crume)

Si les performances sont un problème, vous devez utiliser celui-ci

while (mapOverlays.size() > 1) {
    mapOverlays.remove(mapOverlays.size()-1);
}

Même un peu de micro-optimisation

int last = mapOverlays.size() - 1;
while (last >= 1) {
    mapOverlays.remove(last);
    last -= 1;
}

Si les performances sont vraiment un problème (et que la liste contient beaucoup d'éléments), vous devez utiliser la solution sublist. C'est un peu plus difficile à lire mais probablement la solution la plus rapide si l'instance de liste ne peut pas être recréée (référencé ailleurs).

int size = mapOverlays.size();
for(int n=0;n<size;n++)
{
    mapOverlays.remove(n);
}

En java, si mapOverlays est list, il commence par 0 en premier index.So n = 0 dans pour la boucle.