Entfernen Sie mehrere Elemente aus ArrayList

Ich habe eine Reihe von Indizes und ich wollen zum entfernen von Elementen auf diese Indizes von einem ArrayList. Ich kann nicht eine einfache Abfolge von remove()s denn die Elemente sind verschoben, nachdem jeder Entfernung. Wie kann ich dieses Problem lösen?

InformationsquelleAutor der Frage Jeffrey | 2011-02-09

arraylist java

23

Sortieren der Indizes in absteigender Reihenfolge und entfernen Sie Sie eins nach dem anderen. Wenn Sie das tun, es gibt keine Möglichkeit a nehmen Sie Einfluss auf alle indices, die Sie später entfernen möchten.

Wie Sie sortiert wird, hängt von der Sammlung, den Sie zum speichern der Indizes. Wenn es eine Liste ist, können Sie dies tun:
```
List<Integer> indices;
Collections.sort(indices, new Comparator<Integer>() {
   public int compare(Integer a, Integer b) {
      //todo: handle null
      return b.compareTo(a);
   }
}
```
Bearbeiten

@aioobe fanden die Helfer, dass ich nicht zu finden. Anstelle der oben genannten verwenden, können Sie
```
Collections.sort(indices, Collections.reverseOrder());
```
InformationsquelleAutor der Antwort Mark Peters

Zum entfernen von Elementen an indexes:

Collections.sort(indexes, Collections.reverseOrder());
for (int i : indexes)
    strs.remove(i);

Oder Verwendung der Stream-API aus Java 8:

indexes.sort(Comparator.reverseOrder());
indexes.stream().mapToInt(i -> i).forEach(l::remove);

InformationsquelleAutor der Antwort aioobe

3

Können Sie entfernen Sie die Elemente, angefangen von den größten index nach unten, oder wenn Sie Referenzen auf die Objekte, die Sie entfernen möchten, können Sie die removeAll Methode.

InformationsquelleAutor der Antwort Mansoor Siddiqui
3

Können Sie die Indizes in umgekehrter Reihenfolge. Falls die Indizes in der Reihenfolge, wie 1,2,3, die Sie tun können removeRange(1, 3).

InformationsquelleAutor der Antwort Robby Pond
3

Ich kam hier für das entfernen von Elementen in bestimmten Bereich (d.h., alle Elemente zwischen 2 Indizes), und fand diese:
```
list.subList(indexStart, indexEnd).clear()
```
InformationsquelleAutor der Antwort Aviel Gross

Wenn Sie haben wirklich sehr viele Elemente zu entfernen (und eine lange Liste), kann es schneller sein, Durchlaufen Sie die Liste und fügen Sie alle Elemente, die nicht entfernt werden, um eine neue Liste, da jeder remove()-Schritt in eine array-Liste kopiert alle Elemente nach der entfernt eins nach dem anderen. In diesem Fall, wenn Sie die index-Liste ist nicht sortiert sind (und Sie können Durchlaufen Sie parallel zu der Haupt-Liste), die Sie möglicherweise verwenden möchten, eine HashSet oder BitSet oder ein ähnliches O(1)-access-Struktur für die contains() check:

/**
 * creates a new List containing all elements of {@code original},
 * apart from those with an index in {@code indices}.
 * Neither the original list nor the indices collection is changed.
 * @return a new list containing only the remaining elements.
 */
public <X> List<X> removeElements(List<X> original, Collection<Integer> indices) {
    //wrap for faster access.
    indices = new HashSet<Integer>(indices);
    List<X> output = new ArrayList<X>();
    int len = original.size();
    for(int i = 0; i < len; i++) {
       if(!indices.contains(i)) {
           output.add(original.get(i));
       }
    }
    return output;
}

InformationsquelleAutor der Antwort Paŭlo Ebermann

0

bestellen Sie Ihre Liste von Indizes, wie diese

wenn 2,12,9,7,3 order-desc auf 12,9,7,3,2

tun, und dann diese

for(var i = 0; i < indexes.length; i++) { source_array.remove(indexes[0]); }

dies sollte Ihr problem beheben.

InformationsquelleAutor der Antwort Senad Meškin
0

Wenn die Elemente, die Sie entfernen möchten sind alle zusammen gruppiert, Sie können tun, eine subList(start, end).clear() Betrieb.

Wenn die Elemente, die Sie entfernen möchten verstreut sind, kann es besser sein, erstellen Sie eine neue ArrayList, fügen Sie nur die Elemente, die Sie einbeziehen möchten, und kopieren Sie dann zurück in die ursprüngliche Liste.

Edit: jetzt erkenne ich, das war nicht eine Frage der Leistung, sondern der Logik.

InformationsquelleAutor der Antwort ILMTitan

Sortieren Sie die Indizes so viele gesagt, oder Sie können verwenden einen iterator und call remove()

List<String> list = new ArrayList<String>();
    list.add("0");
    list.add("1");
    list.add("2");
    list.add("3");
    list.add("4");
    list.add("5");
    list.add("6");
    List<Integer> indexes = new ArrayList<Integer>();
    indexes.add(2);
    indexes.add(5);
    indexes.add(3);
    int cpt = 0;
    Iterator<String> it = list.iterator(); 
    while(it.hasNext()){
        it.next();
        if(indexes.contains(cpt)){
            it.remove();
        }
        cpt++;
    }

es hängt davon ab, was Sie brauchen, aber die Art wird schneller sein, in den meisten Fällen

InformationsquelleAutor der Antwort oyo

0

Verwenden Guave! Die Methode, die Sie suchen, ist Iteratoren.removeAll(Iterator removeFrom, Sammlung elementsToRemove)

InformationsquelleAutor der Antwort nanda

Ich glaube, nanda war die richtige Antwort.

List<T> toRemove = new LinkedList<T>();
for (T t : masterList) {
  if (t.shouldRemove()) {
    toRemove.add(t);
  }
}

masterList.removeAll(toRemove);

InformationsquelleAutor der Antwort MrJacqes

möchten Sie vielleicht die Verwendung der Unterliste Methode mit der Auswahl des index, den Sie entfernen möchten, und
dann rufen Sie clear() auf.

(achten Sie darauf, dass der Letzte parameter ist ausgeschlossen, und nur die ersten und die zweiten Elemente werden entfernt):

public static void main(String[] args) {
    //TODO Auto-generated method stub
    ArrayList<String> animals = new ArrayList<String>();
    animals.add("cow");
    animals.add("dog");
    animals.add("chicken");
    animals.add("cat");
    animals.subList(0, 2).clear();
    for(String s:animals)
        System.out.println(s);
}

}

wird das Ergebnis:
Huhn
Katze

InformationsquelleAutor der Antwort Gal Rom

0

Wenn Sie entfernen möchten Positionen X der Größe
```
//a is the ArrayList
a=(ArrayList)a.sublist(0,X-1);
```
InformationsquelleAutor der Antwort Esneyder
0

Vorausgesetzt, Ihr indexes array sortiert ist (z.B.: 1, 3, 19, 29), Sie können dies tun:
```
for (int i = 0; i < indexes.size(); i++){
   originalArray.remove(indexes.get(i) - i);
}
```
InformationsquelleAutor der Antwort dor506
0

Eine effizientere Methode ist, dass ich denke, ich habe nicht gesehen, oben ist das erstellen einer neuen Arraylist und die Auswahl der Indizes, die überleben, indem Sie Sie kopieren in das neue array. Und schließlich weisen Sie die Referenz.

InformationsquelleAutor der Antwort carles
0

Landete ich hier für eine ähnliche Abfrage und @aioobe die Antwort hat mir geholfen herauszufinden, die Lösung.
Allerdings, wenn Sie sind, bevölkern Sie die Liste der Indizes zu löschen, die Sie selbst, in Betracht ziehen diese:
```
indices.add(0, i);
```
Dadurch wird die Notwendigkeit beseitigen, für die (teuren) reverse-Sortierung der Liste vor Durchlaufen, während das entfernen von Elementen aus der Haupt-ArrayList.

InformationsquelleAutor der Antwort dakshtalwar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Bearbeiten