Comment faire pour supprimer tout à partir d'une liste de tableaux en Java, mais le premier élément

Je suis nouveau dans la programmation java, été de programmation en php, donc je suis habitué à ce type de boucle:

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

Je tiens donc à supprimer tout, mais le premier élément, alors pourquoi ne pas ce travail? Comme je l'obtiens, après le retrait, les clés du tableau sont réorganisés ou pas?

Aussi loin que je peux comprendre, vous êtes la cueillette de la taille d'une liste nommée itemizedOverlay, et vous travaillez sur une autre liste nommé mapOverlays. J'espère que c'est normal 😉
Désolé, une erreur de frappe, les tableaux sont les mêmes, j'ai édité

OriginalL'auteur dfilkovi | 2010-06-23

  1. 20

    Comme je l'obtiens, après le retrait, les clés du tableau sont réorganisés ou pas?
    Oui, le point qui est sur la position 2 est sur la position 1) après avoir retiré le point sur la position 1.

    Vous pouvez essayer ceci:

    Object obj = mapOverlays.get(0); //remember first item
mapOverlays.clear(); //clear complete list
mapOverlays.add(obj); //add first item
    Cela peut fonctionner, mais il provoque la liste pour entrer inutilement un état intermédiaire. Si la liste est utilisé en même temps (c'est peut-être un CopyOnWriteArrayList), vous devriez éviter cette solution.

    OriginalL'auteur Daniel Engmann

  2. 93

    Vous pouvez utiliser

    mapOverlays.subList(1, mapOverlays.size()).clear();
    +1 C'est incroyable pour moi que ce n'est pas les mieux notées de réponse. Il est à la fois la plus simple de code et probablement le plus efficace (comme chaque Liste de mise en œuvre sera exécuter la tâche de la manière la plus optimale compte tenu de sa structure).
    holy crap, il est passé de 2 voix les mieux notées en seulement une heure!
    C'est un moyen utile de l'écrire. Si vous regardez le code, il utilise le protégé removeRange, et fait essentiellement la même chose que Plamena de la solution. La principale différence est le nombre d'appels de méthode, et l'endroit où la boucle est. Avec une bonne JIT, je soupçonne qu'ils ont assez de performances similaires. Clairement, le big O est le même.
    Il dépend de la Liste de mise en œuvre. Pour ArrayList (dans l'OpenJDK sources, au moins), removeRange appels Système.arraycopy une fois et ne fait pas d'autres appels de méthode. Dans ce cas particulier, il se déplace de 0 éléments, donc, essentiellement, il n'est de définir les éléments du tableau à la valeur null dans une boucle serrée, et de mettre à jour le champ taille.

    OriginalL'auteur Adam Crume

  3. 7

    Pourquoi n'essayez-vous pas à l'envers?

    int size = itemizedOverlay.size();
for(int n=size-1;n>0;n--)
{
    mapOverlays.remove(n);
}
    -1 Sur certains Liste des implémentations exécuter terriblement, et il ne sera jamais n'importe où près optimale.
    l'OP n'est pas utiliser une Liste." Il a dit dans des termes sans équivoque, c'est un ArrayList. Autant que je sache, ce sera O(n) pour toutes les listes construit en Java. Cela comprend LinkedList.
    Inutilement compliqué. Les réponses ci-dessus, lire mieux.

    OriginalL'auteur Plamena

  4. 4

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

    E temp = mapOverlays.get(0);
mapOverlays = new ArrayList<E>().add(temp);
    Btw, Daniel proposition est peut-être mieux, car il n'est pas de créer un nouvel objet. Si les références à l'objet du séjour.

    OriginalL'auteur Agemen

  5. 2

    Simple.

    mapOverlays = Collections.singletonList(mapOverlays.get(0));
    Peut-être pas ce que l'OP veut - la liste n'a rien, mais le premier élément, mais vous ne pouvez pas ajouter quoi que ce soit de plus. Il n'est donc pas une mauvaise réponse, mais il présente certaines limites.

    OriginalL'auteur Jim

  6. 2

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

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

    C'est probablement ce qui correspond à ce que vous attendez de PHP. Il fonctionne en permanence en supprimant le 1er élément qui change. Cependant, ce qui a de mauvaises performances depuis le tableau interne doit constamment être décalée 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.

    +1 pour souligner l'impact négatif sur les performances de votre solution potentielle. Aussi... n'oubliez pas que vous pouvez toujours étendre liste de tableaux et de les rendre publiques toutes les méthodes qui ont été protégés.
    Vous n'avez pas besoin removeRange (et le problème n'est pas qu'il est protégé, mais qu'il n'existe même pas sur le List interface (et à juste titre)). Voir Adam Crune de réponse.
    l'OP n'est pas à l'aide de la List interface, donc c'est un non sequitur. On pourrait dire qu'il devrait l'être, mais peut-être qu'il est sûr qu'il veut explicitement un tableau de classe en fonction de ses caractéristiques de performance.

    OriginalL'auteur Matthew Flaschen

  7. 1

    Je suis en supposant que mapOverlays est titulaire d'un ArrayList de référence.

    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. (Jusqu'ici tout va bien ...)

    Lorsque vous retirez le nth élément d'un tableau à l'aide de remove(int), les éléments de départ à la position n + 1 et par-dessus tout obtenir déplacé vers le bas par un. Donc, ce que vous faites ne sera pas réellement de travail 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);

    (À noter que la première solution supprime toujours à partir de la fin de la liste, en évitant le besoin de copier des éléments pour combler le trou laissé par la disparition de l'élément. Les performances différentes est important pour une grande liste de tableaux.)

    Toutefois, 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é, ce sera soit vous donner une erreur de compilation, ou le int sera autoboxed comme un Integer et vous (probablement) de ne pas enlever quoi que ce soit. GOTCHA!

    OriginalL'auteur Stephen C

  8. 0

    Si vous utilisez un java.util.List mise en place de tableau, la taille de la matrice devient plus petit à chaque fois que vous supprimez quelque chose et le n+1 élément remplace le n élément. Ce code va finalement suite à ArrayIndecOutOfBoundsException quand n devient plus grande que le dernier indice dans la liste.

    Java a aussi un tableau de type et la taille de l'un ne peuvent pas être modifiés:

    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 comme il est à proximité du comportement que vous êtes après. Toutefois, la Liste des implémentations sont plus flexibles et plus à l'aise dans l'utilisation de 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

    OriginalL'auteur fish

  10. 0

    Utiliser une boucle while pour supprimer tout ce qui est après le premier élément: 

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

    MODIFIER (voir le commentaire d'Adam Crume)

    Si la performance est un problème que vous devriez utiliser ce 

    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 la performance est vraiment un problème (et la liste a un bon nombre d'éléments), vous devez utiliser le sublist solution. C'est un peu plus difficile à lire, mais sans doute la solution la plus rapide si la liste de l'instance ne peut pas être recréé (référencés).

    Pour une liste de tableaux, cela va faire très mal O(n^2) - parce qu'il a pour Système d'appel.arraycopy pour presque l'ensemble de la matrice n-1 fois. Supprimer le dernier élément à la place de l'un à l'indice 1, et il devrait être beaucoup mieux.
    correct, la réponse modifiée, et peut-être le remove(1) solution est encore pire que O(n^2), mais je préfère pour les petites listes pour être plus lisible (OMI) - à la question de ne pas mentionner la performance à tous. Le sublist solution est à la fois élégante et mieux (le meilleur) mais pas tout le monde comprend comment sublist œuvres.
    Je n'ai pas de soins si les gens n'utilisez pas de sous-liste. Je pense juste que la réduction d'exécution de O(n^2) à O(n) vaut bien un petit sacrifice pour des raisons de lisibilité. Le remove(1) solution peut fonctionner très bien pour les petites listes, mais je pense que c'est mieux d'avoir un code qui fonctionne bien pour tout liste de.

    OriginalL'auteur Carlos Heuberger

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

    En java, si mapOverlays est de la liste, puis il commence avec 0 comme un premier indice.Si n=0 dans la boucle for.

    Je pense que l'OP veut garder le premier élément dans la liste et supprimer tout le reste.

    OriginalL'auteur Sonal Patil