Existují dva způsoby, jak odstranit objekty z ArrayList v Javě, první pomocí remove() metoda, a za druhé pomocí Iterátoru. ArrayList poskytuje přetíženou metodu remove (), jeden akceptovat index objektu, který má být odstraněn, tj. odebrat(int index), a další přijmout objekt, který má být odstraněn, tj. odebrat(Object obj). Pravidlem je, že pokud znáte index objektu, použijte první metodu, jinak použijte druhou metodu. Mimochodem, musíte pamatovat na použití ArrayList odstranit metody, pouze pokud nejste iterování přes ArrayList, pokud jste iterování pak použijte iterátor.metoda remove (), pokud tak neučiníte, může mít za následek ConcurrentModificationException v Javě. Další gotcha může nastat kvůli autoboxingu. Pokud se podíváte pozorně, že dvě metody odebrání, remove (int index) a remove (Object obj) jsou nerozeznatelné, pokud se pokoušíte odstranit z Arraylistu celých čísel.
Předpokládejme, že máte tři objekty v Arraylistu tj. a chcete odstranit druhý objekt, který je 2. Můžete volat remove (2), což je vlastně výzva k odebrání (objekt), pokud zvážíte autoboxing, ale bude interpretován jako výzva k odstranění 3rd element, interpretací jako remove (index).
o tomto problému jsem hovořil dříve ve svém článku o osvědčených postupech, které je třeba dodržovat při metodách přetížení v Javě. Kvůli méně známému rozšiřujícímu se pravidlu a autoboxingu může špatně přetížená metoda vytvořit mnoho nejednoznačností.

příklad kódu pro odstranění prvků z Arraylistu

otestujme nad teorií jednoduchý příklad kódu Arraylistu s celými čísly. Následující program má ArrayList celých čísel obsahujících 1, 2 a 3, což přesně odpovídá indexu.

 package test;import java.util.ArrayList; import java.util.Seznam;/** * * @author http://java67.blogspot.com */public class JavaTutorial{ /** * @param args the command line arguments */ public static void main(String args) { List<Integer> čísla = new ArrayList<Integer>(); čísla.přidat (1); Čísla.přidat (2); čísla.přidat (3); Systém.mimo.println ("ArrayList obsahuje:" + čísla); // volání odstranit (index) čísla.remove (1); //removing object at index 1 tj 2.objekt, který je 2 / / Volání odebrat(objekt) čísla.odebrat (3); }}Výstup: ArrayList obsahuje: výjimku ve vlákně" hlavní " java.lang.IndexOutOfBoundsException: Index: 3, Velikost: 2 v Javě.util.ArrayList.rangeCheck(ArrayList.Jáva: 635) v Jávě.util.ArrayList.odebrat (ArrayList.java: 474) při testu.Test.hlavní (Test.java: 33) výsledek Java: 1

můžete vidět, že druhý hovor je také považován za remove (index). Nejlepší způsob, jak odstranit nejednoznačnost, je uzavřít autoboxing a poskytnout skutečný objekt, jak je uvedeno níže.

System.mimo.println ("ArrayList Before:" + čísla); / / volání odstranit (index)čísla.remove (1); //removing object at index 1 tj 2.objekt, který je 2 / / Volání odebrat(objekt) čísla.odebrat (nové celé číslo (3)); Systém.mimo.println ("ArrayList After:" + numbers);Output :ArrayList Before: ArrayList After: 

tentokrát to funguje, ale obávám se líných vývojářů, jako jsem já, což bere autoboxing jako samozřejmost. Nyní se podívejme na odstranění objektu z Arraylistu při iteraci nad nimi. Než budete pokračovat dále, musíte být obeznámeni s Iterátorem v Javě.

Odstranit Objekt Z ArrayList pomocí Iterator

Tohle je ve skutečnosti subtilní detail programování v jazyce Java, není zřejmé, pro první časovače, protože kompilátor si bude stěžovat, i když používáte remove() metoda v jazyce java.util.ArrayList, při použití Iterátoru. Uvědomíte si, jen to vaše chyba, když vidíte ConcurrentModificationException, což je samo o sobě zavádějící, a můžete strávit nespočet hodin hledání jiném vlákně, což je úprava, že ArrayList, protože Souběžné slovo. Podívejme se na příklad.

public static void main(String args) { List<Integer> čísla = new ArrayList<Integer>(); čísla.přidat (101); čísla.přidat (200); čísla.přidat (301); čísla.přidat (400); systém.mimo.println ("ArrayList Before:" + čísla); Iterator<Integer> itr = numbers.iterator(); // remove all even numbers while (itr.hasNext()) { Integer number = itr.next(); if (number % 2 == 0) { numbers.remove(number); } } System.out.println("ArrayList After : " + numbers); }Output :ArrayList Before : Exception in thread "main" java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859) at java.util.ArrayList$Itr.next(ArrayList.java:831) at Testing.main(Testing.java:28)

Můžete ConcurrentModificationException, kvůli volání odebrat () metodu z Arraylistu. To je snadné v jednoduchých příkladech, jako je tento, ale v reálném projektu, to může být opravdu těžké. Nyní, chcete-li tuto výjimku opravit, stačí nahradit volání čísel.odebrat () do itr.odebrat(), tím se odstraní aktuální objekt, který Iterujete, jak je uvedeno níže:

 systém.mimo.println ("ArrayList Before:" + numbers); Iterator< Integer> itr = numbers.iterator();// odstranit všechna sudá čísla (itr.hasNext ()) { Integer number = itr.další(); pokud (číslo % 2 = = 0) {itr.odstranit ();}} systém.mimo.println ("ArrayList After:" + numbers);OutputArrayList Before: ArrayList After: 

To je vše na tomto příspěvku o tom, jak odstranit objekt z Arraylistu v Javě. Naučili jsme se dva způsoby, jak odstranit objekt nebo prvek z Arraylistu. Mimochodem, vždy byste měli použít odstranit(index) odstranit objekt, Pokud nejste iterování, jinak vždy použít iterátor odebrat () metoda pro odstranění objektu z Arraylistu. Mimochodem výše uvedené tipy budou pracovat s jakoukoli implementací seznamu založeného na indexu.
Další učení
Java in-Depth: Stát Kompletní Java Engineer
Java Základy: Sbírky
Datové Struktury a Algoritmy: Hluboký Ponor Pomocí Java
Algoritmy a Datové Struktury – Část 1 a 2,
Datové Struktury v Javě 9 Heinz Kabutz