arraylist methods java tutorial with example programs
V tomto kurzu budeme diskutovat o metodách Java ArrayList, jako jsou add, addAll, remove, removeAll, size, contains, keepAll, Sort, Reverse atd. S příklady:
V předchozím kurzu jsme prozkoumali datovou strukturu ArrayList a třídu ArrayList poskytovanou pro tuto datovou strukturu / kolekci v Javě. Naučili jsme se vytváření, inicializaci atd. Objektů ArrayList.
Kromě těchto funkcí, které nám pomáhají definovat ArrayList, poskytuje třída ArrayList v Javě také plnohodnotné funkční API, které se skládá z metod, které se používají k manipulaci s objekty ArrayList.
=> Zkontrolujte VŠECHNY výukové programy Java zde.
Tyto metody nám umožňují přidávat, mazat, prohledávat prvky v ArrayList a také načítat délku / velikost prvků ArrayList atd.
V tomto tutoriálu budeme podrobně diskutovat o těchto metodách pomocí jednoduchých příkladů programování.
Co se naučíte:
- Metody ArrayList v Javě
- Přidat ArrayList
- ArrayList addAll
- ArrayList Přidat do popředí
- ArrayList odebrat
- ArrayList removeAll
- ArrayList removeRange
- ArrayList velikost (délka)
- ArrayList obsahuje
- Získat ArrayList
- Sada ArrayList (Nahradit prvek)
- ArrayList jasný
- ArrayList isEmpty
- ArrayList indexOf
- ArrayList lastIndexOf
- ArrayList toArray
- Klon ArrayList
- ArrayList subList
- ArrayList keepAll
- ArrayList Iterator
- ArrayList listIterator
- Přidat pole do ArrayList v Javě
- Třídit ArrayList v Javě
- Obrátit seznam Array v Javě
- Odeberte duplikáty ze seznamu ArrayList v Javě
- Shuffle (Randomize) Seznam Array v Javě
- Často kladené otázky
- Závěr
Metody ArrayList v Javě
V následující tabulce jsou uvedeny všechny metody, které poskytuje třída ArrayList.
Metoda | Metoda Prototyp | Popis metody |
---|---|---|
Obsahuje | boolean obsahuje (Objekt o) | Zkontroluje, zda seznam obsahuje daný prvek „o“. Vrátí true, pokud je prvek přítomen. |
Přidat | booleovský doplněk (E e) | Přidá daný prvek e na konec seznamu. |
void add (int index, E element) | Přidá daný prvek „prvek“ na určenou pozici „index“. | |
Přidat vše | boolean addAll (kolekce c) | Přidá všechny prvky v dané kolekci c na konec seznamu. |
boolean addAll (int index, kolekce c) | Přidá všechny prvky v dané kolekci c na pozici určenou indexem v seznamu. | |
Průhledná | prázdnota clear () | Vymaže seznam odstraněním všech prvků ze seznamu. |
Klonovat | Klon objektu () | Vytvoří mělkou kopii daného ArrayList. |
zajistit kapacitu | void ensureCapacity (int minCapacity) | Zvyšuje kapacitu ArrayList a zajišťuje, že má minCapacity. |
Dostat | E get (int index) | Vrátí prvek ze seznamu na pozici určenou parametrem „index“. |
indexOf | int indexOf (Objekt o) | Vrátí index prvního výskytu prvku o v seznamu. -1, pokud prvek o není v seznamu. |
je prázdný | boolean isEmpty () | Zkontroluje, zda je daný seznam prázdný. |
Iterátor | Iterátor iterátor () | Vrátí iterátor, který bude procházet prvky seznamu ve správném pořadí. |
lastIndexOf | int lastIndexOf (Objekt o) | Vrátí index posledního výskytu zadaného prvku o v seznamu. -1, pokud prvek není v seznamu. |
listIterator | ListIterator listIterator () | Vrátí iterátor seznamu, který bude procházet prvky daného seznamu. |
ListIterator listIterator (int index) | Vrátí iterátor seznamu počínaje zadanou polohou „index“ pro procházení prvky daného seznamu. | |
odstranit | E remove (int index) | Odstraní prvek v „indexu“ v seznamu ArrayList. |
boolean remove (Objekt o) | Odstraní první výskyt prvku o ze seznamu. | |
odebrat všechny | boolean removeAll (kolekce c) | Odebere všechny prvky ze seznamu, které odpovídají prvkům v dané kolekci c. |
removeRange | protected void removeRange (int fromIndex, int toIndex) | Odebere ze seznamu prvky určené v daném rozsahu, odIndex (včetně) doIndex (exkluzivní). |
zachovat vše | boolean keepAll (kolekce c) | Zachová ty prvky v seznamu, které odpovídají prvkům v dané kolekci c. |
soubor | Sada E (int index, prvek E) | Nastaví hodnotu prvku v daném „indexu“ na novou hodnotu danou v „prvku“. |
velikost | int velikost () | Vrátí celkový počet prvků nebo délku seznamu. |
subList | Seznam sublistů (int fromIndex, int toIndex) | Vrátí podřízený seznam mezi daným rozsahem, odIndex do poIndex pro daný seznam. |
toArray | Objekt () toArray () | Převede daný seznam na pole. |
T () toArray (T () a) | Převede daný seznam na pole typu daného znakem a. | |
trimToSize | void trimToSize () | Ořízne kapacitu ArrayList na velikost nebo počet prvků přítomných v seznamu. |
Dále budeme podrobně diskutovat o každé z těchto metod z API funkce ArrayList a představíme příklady programování. Po projednání všech výše uvedených metod pojmeme také některé konkrétní operace, které se provádějí pomocí ArrayLists, které nejsou součástí API funkce ArrayList.
Přidat ArrayList
Já
Prototyp: booleovský doplněk (E e)
Parametry: e => Prvek, který má být přidán do ArrayList.
Návratová hodnota: true => Prvek byl úspěšně přidán.
Popis: Přidá daný prvek e na konec seznamu.
II.
Prototyp: void add (int index, E element)
Parametry:
index => Poloha, ve které má být prvek přidán.
Element => Element, který má být přidán do ArrayList.
Návratová hodnota: prázdnota
Popis: Přidá daný prvek „prvek“ na určenou pozici „index“ posunutím prvku na této pozici a následnými prvky doprava.
Výjimky: IndexOutOfBoundsException => Pokud je zadaný index mimo rozsah.
ArrayList addAll
Já
Prototyp: boolean addAll (kolekce c)
Parametry: c => Kolekce, jejíž prvky mají být přidány do ArrayList.
Návratová hodnota: true => Pokud operace změnila ArrayList.
Popis: Přidá všechny prvky v dané kolekci c na konec seznamu. Výsledek operace není definován, pokud se kolekce během operace změní.
Výjimky: NullPointerException => Pokud je daná kolekce c je null.
yl
Prototyp: boolean addAll (int index, kolekce c)
Parametry: index => Pozice, na kterou mají být přidány prvky v dané kolekci.
Návratová hodnota: true => Pokud se seznam v důsledku operace změnil.
Popis: Přidá všechny prvky v dané kolekci c na pozici určenou indexem v seznamu. Prvek v zadaném indexu a následující prvky jsou posunuty doprava. Výsledek operace není definován, pokud se přidávaná kolekce mění, když operace probíhá.
Výjimky: IndexOutOfBoundsException: pokud je index, do kterého má být kolekce přidána, mimo meze
NullPointerException: pokud je daná kolekce c null.
Následující program Java demonstruje použití metod add a addAll.
import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print the list System.out.println('Initial ArrayList:' + city_List); //add an element at index 1 using add method overload city_List.add(1, 'NYC'); //print the list System.out.println('
rrayList after adding element at index 1:' + city_List); //define a second list ArrayList more_Cities = new ArrayList(Arrays.asList('Pune', 'Hyderabad')); //use addAll method to add the list to ArrayList at index 4 city_List.addAll(4,more_Cities); //print the list System.out.println('
ArrayList after adding list at index 4:' + city_List); } }
Výstup:
Initial ArrayList: (Dillí, Bombaj, Chennai, Kalkata)
rrayList po přidání prvku do indexu 1: (Dillí, NYC, Bombaj, Chennai, Kalkata)
ArrayList po přidání seznamu na index 4: (Dillí, NYC, Bombaj, Chennai, Pune, Hyderabad, Kalkata)
Výše uvedený program používá k přidání prvků do seznamu obě verze metody add. Také přidá kolekci do seznamu v zadaném indexu. Všimněte si posunutí prvků napravo od ArrayList, jak je patrné z výstupu programu.
ArrayList Přidat do popředí
Jak již bylo zmíněno, první verze metody add přidává prvky na konec seznamu. Pokud chcete přidat prvky na začátek ArrayList, musíte použít druhou verzi metody add. Tato metoda přidání bere index jako parametr. Tento index je pozice, na kterou má být prvek přidán.
Chcete-li tedy přidat prvek na začátek seznamu, musíte zadat index jako 0, což je začátek seznamu.
Následující program přidá prvek do přední části ArrayList.
import java.util.ArrayList; public class Main { public static void main(String() args) { //define new ArrayList and initialize it ArrayList numList = new ArrayList(); numList.add(5); numList.add(7); numList.add(9); //print the ArrayList System.out.println('Initial ArrayList:'); System.out.println(numList); //use add method with index=0 to add elements to the beginning of the list numList.add(0, 3); numList.add(0, 1); System.out.println('ArrayList after adding elements at the beginning:'); //print ArrayList System.out.println(numList); } }
Výstup:
Initial ArrayList:
(5, 7, 9)
ArrayList po přidání prvků na začátku:
(1, 3, 5, 7, 9)
ArrayList odebrat
I.
Prototyp: E remove (int index)
Parametry: index => Poloha, ve které má být prvek odebrán z ArrayList.
Návratová hodnota: E => Prvek, který je odstraněn
Popis: Odstraní prvek v „indexu“ v seznamu ArrayList a přesune následující prvky doleva.
Výjimky: IndexOutOfBoundsException => Zadaný index je mimo rozsah.
II.
Prototyp: boolean remove (Objekt o)
Parametry: o => Prvek, který má být odstraněn z ArrayList.
Návratová hodnota: true => Pokud je prvek v seznamu.
Popis: Odstraní první výskyt prvku o ze seznamu. Pokud prvek není v seznamu, pak tato operace nemá žádný účinek. Jakmile je prvek odstraněn, následující prvky jsou posunuty doleva.
ArrayList removeAll
Prototyp: boolean removeAll (kolekce c)
Parametry: c => Sbírka, jejíž prvky se shodují s prvky ArrayList a mají být odstraněny.
Návratová hodnota: true => Pokud je ArrayList operací změněn.
Popis: Odebere všechny prvky ze seznamu, které odpovídají prvkům v dané kolekci c. Výsledkem je, že zbývající prvky jsou posunuty nalevo od seznamu.
Výjimky: ClassCastException => Třída není stejná jako u určené kolekce, což znamená, že třída je nekompatibilní.
NullPointerException => Pokud je daná kolekce c null; nebo má-li c nulový prvek a kolekce to nepovoluje.
ArrayList removeRange
Prototyp: protected void removeRange (int fromIndex, int toIndex)
Parametry: fromIndex => Index počátečního prvku rozsahu, který má být odstraněn.
toIndex => Index prvku za posledním prvkem v rozsahu, který má být odstraněn.
Návratová hodnota: prázdnota
Popis: Odebere ze seznamu prvky určené v daném rozsahu, odIndex (včetně) doIndex (exkluzivní). Tato operace zkrátí délku seznamu o (toIndex-fromIndex). Tato operace nemá žádný účinek v případě fromIndex = toIndex.
Výjimky: IndexOutOfBoundsException => Pokud je některý z indexů (fromIndex nebo toIndex) mimo hranice.
Implementujme program Java, abychom demonstrovali některé z těchto metod odebrání, které jsme probrali výše.
import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(Arrays.asList('Delhi','Mumbai','Chennai', 'Kolkata', 'Pune', 'Hyderabad')); //print the list System.out.println('Initial ArrayList:' + city_List); //remove element at index 2 city_List.remove(2); //print the list System.out.println('
ArrayList after removing element at index 2:' + city_List); //remove the element 'Kolkata' city_List.remove('Kolkata'); //print the list System.out.println('
ArrayList after removing element -> Kolkata:' + city_List); //create new list ArrayList newCities=new ArrayList(Arrays.asList('Delhi','Hyderabad')); //call removeAll to remove elements contained in newCities list. city_List.removeAll(newCities); //print the list System.out.println('
ArrayList after call to removeAll:' + city_List); } }
Výstup:
Initial ArrayList: (Dillí, Bombaj, Chennai, Kalkata, Pune, Hyderabad
ArrayList po odstranění prvku v indexu 2: (Dillí, Bombaj, Kalkata, Pune, Hyderabad)
ArrayList po odstranění prvku -> Kalkata: (Dillí, Bombaj, Pune, Hyderabad)
ArrayList po volání removeAll: (Mumbai, Pune)
ArrayList velikost (délka)
Prototyp: int velikost ()
Parametry: NULA
Návratová hodnota: int => Počet prvků v ArrayList.
Popis: Vrátí celkový počet prvků nebo délku ArrayList.
Zajistěte kapacitu
Prototyp: void ensureCapacity (int minCapacity)
Parametry: minCapacity => Minimální požadovaná kapacita pro ArrayList.
Návratová hodnota: prázdnota
Popis: Zvyšuje kapacitu ArrayList, aby zajistil, že má minCapacity.
trimToSize
Prototyp: void trimToSize ()
Parametry: NULA
Návratová hodnota: prázdnota
Popis: Ořízne kapacitu ArrayList na velikost nebo počet prvků přítomných v seznamu.
Níže uvedený příklad programování ukazuje metody size (), ensureCapacity () a trimToSize ().
import java.util.ArrayList; public class Main { public static void main(String () args) { //Create and initialize Arraylist ArrayList evenList=new ArrayList(5); System.out.println('Initial size: '+evenList.size()); evenList.add(2); evenList.add(4); evenList.add(6); evenList.add(8); evenList.add(10); //print the list and size System.out.println('Original List: ' + evenList); System.out.println('ArrayList Size after add operation: '+evenList.size()); //call ensureCapacity () with minimum capacity =10 evenList.ensureCapacity(10); //add two more elements evenList.add(12); evenList.add(14); //print the size again System.out.println('ArrayList Size after ensureCapacity() call and add operation: '+evenList.size()); //call trimToSize() evenList.trimToSize(); //print the size and the ArrayList System.out.println('ArrayList Size after trimToSize() operation: '+evenList.size()); System.out.println('ArrayList final: '); for(int num: evenList){ System.out.print(num + ' '); } } }
Výstup:
Počáteční velikost: 0
Původní seznam: (2, 4, 6, 8, 10)
Velikost pole ArrayList po operaci přidání: 5
Velikost ArrayList po volání operace callCapacity () a přidání: 7
Velikost pole po operaci trimToSize (): 7
ArrayList final:
2 4 6 8 10 12 14
ArrayList obsahuje
Prototyp: boolean obsahuje (Objekt o)
Parametry: o => Prvek, který má být zkontrolován, pokud je přítomen v ArrayList.
Návratová hodnota: true => Pokud ArrayList obsahuje prvek o.
Popis: Zkontroluje, zda seznam obsahuje daný prvek „o“. Vrátí true, pokud je prvek přítomen.
V následujícím programu používáme metodu „obsahuje“.
import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call contains method to check if different strings are present in ArrayList System.out.println('ArrayList contains ('Red Green'): ' +colorsList.contains('Red Green')); System.out.println('ArrayList contains ('Blue'): ' +colorsList.contains('Blue')); System.out.println('ArrayList contains ('Yellow'): ' +colorsList.contains('Yellow')); System.out.println('ArrayList contains ('White'): ' +colorsList.contains('White')); } }
Výstup:
ArrayList obsahuje („Red Green“): false
ArrayList obsahuje („Modrý“): true
ArrayList obsahuje („Žlutý“): false
ArrayList obsahuje („White“): true
jak otevírat soubory .java
Jak je znázorněno ve výše uvedeném výstupu, metoda ‘obsahuje‘ kontroluje, zda je zadaný argument v ArrayList, a vrací true nebo false.
Získat ArrayList
Prototyp: E get (int index)
Parametry: index => Index, u kterého se má prvek načíst z ArrayList.
Návratová hodnota: E => Hodnota prvku v daném indexu v seznamu ArrayList.
Popis: Vrátí prvek ze seznamu na pozici určenou parametrem „index“.
Výjimky: IndexOutOfBoundsException => Pokud je index mimo meze.
Sada ArrayList (Nahradit prvek)
Prototyp: Sada E (int index, prvek E)
Parametry: index => Index, u kterého má být prvek nahrazen.
Element => Nový prvek, který má být nastaven na zadaný index.
Návratová hodnota: E => Prvek, který je nahrazen nastavenou operací.
Popis: Nastaví hodnotu prvku v daném „indexu“ na novou hodnotu danou „prvkem“.
Výjimky: IndexOutOfBoundsException => Pokud je index mimo meze
Níže uvedený program Java používá metodu get () a set () k načtení a nahrazení hodnot v seznamu ArrayList.
import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call get () method to retrieve value at index 2 System.out.println('Entry at index 2 before call to set: ' + colorsList.get(2)); //replace the value at index 2 with new value colorsList.set(2,'Yellow'); //print the value at index 2 again System.out.println('Entry at index 2 after call to set: ' + colorsList.get(2)); } }
Výstup:
Položka v indexu 2 před voláním do nastavení: Modrá
Položka na indexu 2 po volání do nastavení: Žlutá
ArrayList jasný
Prototyp: prázdnota clear ()
Parametry: NULA
Návratová hodnota: prázdnota
Popis: Vymaže seznam odstraněním všech prvků ze seznamu.
ArrayList isEmpty
Prototyp: boolean isEmpty ()
Parametry: NULA
Návratová hodnota: true => pokud je seznam prázdný
Popis: Zkontroluje, zda je daný seznam prázdný.
Funkce Clear () a isEmpty () jsou ukázány níže.
import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //print the ArrayList System.out.println('The ArrayList: ' + colorsList); //call clear() nethod on ArrayList colorsList.clear(); //check if ArrayList is empty using isEmpty() method System.out.println('Is ArrayList empty after clear ()? :' + colorsList.isEmpty()); } }
Výstup:
Seznam Array: (červená, zelená, modrá, bílá)
Je ArrayList prázdný po clear ()? :skutečný
ArrayList indexOf
Prototyp: int indexOf (Objekt o)
Parametry: o => Prvek, jehož index se nachází v seznamu ArrayList.
Návratová hodnota: int => Index prvního výskytu prvku v seznamu.
Popis: Vrátí index prvního výskytu prvku o v seznamu. -1, pokud prvek o není v seznamu.
ArrayList lastIndexOf
Prototyp: int lastIndexOf (Objekt o)
Parametry: o => Hledaný prvek.
Návratová hodnota: int => Index posledního výskytu prvku v seznamu.
Popis: Vrátí index posledního výskytu zadaného prvku o v seznamu. -1, pokud prvek není v seznamu.
Níže uvedený program Java demonstruje metody indexOf a lastIndexOf z ArrayList.
import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize intList ArrayList intList = new ArrayList(); intList.add(1); intList.add(1); intList.add(2); intList.add(3); intList.add(5); intList.add(3); intList.add(2); intList.add(1); intList.add(1); //print the ArrayList System.out.println('The ArrayList: ' + intList); //call indexOf() and lastIndexOf() methods to check the indices of specified elements System.out.println('indexOf(1) : ' + intList.indexOf(1)); System.out.println('lastIndexOf(1) : ' + intList.lastIndexOf(1)); System.out.println('indexOf(2) : ' + intList.indexOf(2)); System.out.println('lastIndexOf(2) : ' + intList.lastIndexOf(2)); System.out.println('indexOf(3) : ' + intList.indexOf(3)); System.out.println('lastIndexOf(3) : ' + intList.lastIndexOf(3)); System.out.println('indexOf(5) : ' + intList.indexOf(5)); System.out.println('lastIndexOf(5) : ' + intList.lastIndexOf(5)); } }
Výstup:
Seznam Array: (1, 1, 2, 3, 5, 3, 2, 1, 1)
indexOf (1): 0
lastIndexOf (1): 8
indexOf (2): 2
lastIndexOf (2): 6
indexOf (3): 3
lastIndexOf (3): 5
indexOf (5): 4
lastIndexOf (5): 4
ArrayList toArray
Prototyp: Objekt () toArray ()
Parametry: NULA
Návratová hodnota: Objekt () => pole. Toto vrácené pole obsahuje všechny prvky seznamu ve správném pořadí.
Popis: Převede daný seznam na pole.
Prototyp: T () toArray (T () a)
Parametry: a => Pole pro uložení prvků seznamu. Pokud velikost pole není dostatečná pro prvky seznamu, vytvoří se pro ukládání prvků další pole se stejným typem jako a.
Návratová hodnota: T () => Pole, které obsahuje všechny prvky seznamu.
Popis: Převede daný seznam na pole typu daného znakem a.
Výjimky: ArrayStoreException => Pokud existuje neshoda v runtime typu pole a runtime typu nebo supertypu jeho prvků.
NullPointerException => Dané pole má hodnotu null
Níže uvedený program Java demonstruje metodu toArray ArrayList.
import java.util.*; public class Main { public static void main(String() args) { // define and initialize ArrayList ArrayList intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); // print ArrayList System.out.println('ArrayList: ' + intList); //declare array Integer myArray() = new Integer(intList.size()); //use toArray method to convert ArrayList to Array myArray = intList.toArray(myArray); //print the Array System.out.println('Array from ArrayList:' + Arrays.toString(myArray)); } }
Výstup:
ArrayList: (10, 20, 30, 40, 50)
Pole z ArrayList: (10, 20, 30, 40, 50)
Klon ArrayList
Prototyp: Klon objektu ()
Parametry: NULA
Návratová hodnota: Object => Clone of the ArrayList instance.
Popis: Vytvoří mělkou kopii daného ArrayList.
import java.util.ArrayList; public class Main { public static void main(String a()){ ArrayList fruitsList = new ArrayList(); //Adding elements to the ArrayList fruitsList.add('Apple'); fruitsList.add('Orange'); fruitsList.add('Melon'); fruitsList.add('Grapes'); System.out.println('Original ArrayList: '+fruitsList); ArrayList clone_list = (ArrayList)fruitsList.clone(); System.out.println('Cloned ArrayList: '+ clone_list); //add one elmeent & remove one element from original arraylist fruitsList.add('Mango'); fruitsList.remove('Orange'); //print original and cloned ArrayList again System.out.println('
Original ArrayList after add & remove:'+fruitsList); System.out.println('Cloned ArrayList after original changed:'+clone_list); } }
Výstup:
Original ArrayList: (Apple, Orange, Melon, Grapes)
Cloned ArrayList: (Apple, Orange, Melon, Grapes)
Původní seznam ArrayList po přidání a odebrání: (Apple, Melon, Grapes, Mango)
Cloned ArrayList po změně originálu: (Apple, Orange, Melon, Grapes)
Z výše uvedeného výstupu programu můžete vidět, že klonovaný ArrayList je mělkou kopií původního ArrayList. To znamená, že když se změní původní ArrayList, tyto změny se v klonovaném ArrayList neodráží, protože nesdílejí umístění paměti každého prvku.
Pro vytvoření hluboké kopie Array je třeba projít původní ArrayList a každý z jejích prvků je třeba zkopírovat do cílového ArrayList.
ArrayList subList
Prototyp: Seznam sublistů (int fromIndex, int toIndex)
Parametry: fromIndex => Počáteční index rozsahu (včetně)
toIndex => Konec indexu rozsahu (exkluzivní)
Návratová hodnota: Seznam => Podlist seznamu v daném rozsahu.
Popis: Vrátí subList mezi daným rozsahem, fromIndex a indexem pro daný seznam. Všimněte si, že tento sublist nebo zobrazení seznamu v daném rozsahu podporuje všechny operace podporované seznamem. Pokud fromIndex = toIndex, není vráceno žádné zobrazení.
Výjimky: IndexOutOfBoundsException => Vyvoláno, když je hodnota toIndex mimo rozsah.
IllegalArgumentException => If fromIndex> toIndex tj. Indexy jsou mimo pořadí.
Podívejme se na příklad metody subList.
import java.util.ArrayList; import java.util.List; class Main{ public static void main(String a()){ //create and initialize the ArrayList ArrayList intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); intList.add(30); intList.add(35); intList.add(40); intList.add(45); intList.add(50); //print the ArrayList System.out.println('Original ArrayList: '+intList); //create a sublist for the given ArrayList ArrayList sub_ArrayList = new ArrayList(intList.subList(2, 6)); //print the sublist System.out.println('Sublist of given ArrayList: '+sub_ArrayList); } }
Výstup:
Original ArrayList: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
Sublist daného ArrayList: (15, 20, 25, 30)
ArrayList keepAll
Prototyp: boolean keepAll (kolekce c)
Parametry: c => Kolekce s prvky, které mají být zachovány v seznamu.
Návratová hodnota: true => Pokud se ArrayList v důsledku operace změnil.
Popis: Zachová ty prvky v seznamu, které odpovídají prvkům v dané kolekci c.
Výjimky: ClassCastException => Typ kolekce a typ seznamu se neshodují
NullPointerException => Daná kolekce má hodnotu null nebo seznam obsahuje prvek null a kolekce neumožňuje hodnoty null.
Následující program ukazuje metodu keepAll.
import java.util.*; class Main{ public static void main(String args()){ //create and initialize ArrayList ArrayList colorsList=new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print the ArrayList System.out.println('Original ArrayList:' + colorsList); //define another collection ArrayList color_collection=new ArrayList(); color_collection.add('Red'); color_collection.add('Blue'); System.out.println('Collection elements to be retained in the list:' + color_collection); //call retainAll method with above collection as an argument colorsList.retainAll(color_collection); //print the ArrayList after retainAll call. System.out.println('ArrayList after retainAll call:' + colorsList); } }
Výstup:
Original ArrayList: (červená, zelená, modrá, žlutá)
Prvky kolekce, které mají být v seznamu zachovány: (červená, modrá)
ArrayList po keepAll volání: (červená, modrá)
ArrayList Iterator
Prototyp: Iterátor iterátor ()
Parametry: NULA
Návratová hodnota: Iterator => iterátor nad prvky seznamu.
Popis: Vrátí iterátor, který bude procházet prvky seznamu ve správném pořadí.
ArrayList listIterator
I.
Prototyp: ListIterator listIterator ()
Parametry: NULA
Návratová hodnota: ListIterator => listIterator nad prvky seznamu.
Popis: Vrátí iterátor seznamu, který bude procházet prvky daného seznamu.
II.
Prototyp: ListIterator listIterator (int index)
Parametry: index => Poloha prvního prvku v listIterátoru.
Návratová hodnota: ListIterator => ListIterator pro seznam ze zadaného indexu.
Popis: Vrátí iterátor seznamu počínaje zadanou polohou „index“ pro procházení prvky daného seznamu.
Výjimky: IndexOutOfBoundsException => Daný index je mimo rozsah.
Příklad metod iterator () a listIterator ().
import java.util.*; class Main{ public static void main(String args()){ //create ArrayList and initialize it ArrayList cities=new ArrayList(); cities.add('Mumbai'); cities.add('Pune'); cities.add('Hyderabad'); cities.add('Delhi'); //use iterator() method to traverse through the list System.out.println('List contents using Iterator () method:'); Iterator iter=cities.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } //use listIterator() method to traverse through the list System.out.println('
List contents using listIterator () method:'); ListIterator list_iter=cities.listIterator(); while(list_iter.hasNext()) { System.out.print(list_iter.next() + ' '); } } }
Výstup:
Seznam obsahu pomocí metody Iterator ():
Mumbai Pune Hyderabad Dillí
Seznam obsahu pomocí metody listIterator ():
Mumbai Pune Hyderabad Dillí
Přidat pole do ArrayList v Javě
ArrayList podporuje metodu addAll pro přidání prvků kolekce do ArrayList. Podobným způsobem můžete do pole ArrayList přidat také pole. To se provádí pomocí metody ‘Collections.addAll’.
Příklad přidání pole do seznamu ArrayList.
import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print ArrayList System.out.println('
Initial ArrayList :' + city_List); //define an array. String() myArray = new String(){'Cochin', 'Goa'}; //add the array to the ArrayList Collections.addAll(city_List,myArray); //print the ArrayList System.out.println('
ArrayList after adding array :' + city_List); } }
Výstup:
Initial ArrayList: (Dillí, Bombaj, Chennai, Kalkata)
ArrayList po přidání pole: (Dillí, Bombaj, Chennai, Kalkata, Kóčin, Goa)
Třídit ArrayList v Javě
ArrayList používá k seřazení svých prvků metodu Collections.sort. Ve výchozím nastavení je seznam seřazen vzestupně metodou Collections.sort. Pokud má být ArrayList seřazen v sestupném pořadí, musíte metodu třídění poskytnout parametr „Collections.reverseOrder ()“.
Níže je uveden program pro třídění ArrayList vzestupně a sestupně:
import java.util.*; public class Main { public static void main(String args()){ //Create and initialize an ArrayList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print initial ArrayList System.out.println('Initial ArrayList:' + colorsList); //sort ArrayList in ascending order Collections.sort(colorsList); //print sorted ArrayList System.out.println('
ArrayList sorted in ascending order:'); System.out.println(colorsList); //sort ArrayList in reverse(desending) order Collections.sort(colorsList, Collections.reverseOrder()); //print sorted list System.out.println('
ArrayList sorted in descending order:'); System.out.println(colorsList); } }
Výstup:
Initial ArrayList: (červená, zelená, modrá, žlutá)
ArrayList seřazený vzestupně:
(Modrá, zelená, červená, žlutá)
ArrayList seřazeno sestupně:
(Žlutá, červená, zelená, modrá)
V případě, že ArrayList obsahuje jako prvky další objekty třídy, můžete využít rozhraní Porovnatelný a Porovnávač. Více podrobností o rozhraních pojednáme v našich pozdějších cvičeních.
Obrátit seznam Array v Javě
ArrayList můžete také obrátit v Javě. Jednou z metod, jak toho dosáhnout, je použít tradiční metodu procházení ArrayList v opačném pořadí a zkopírovat každý prvek do nového ArrayList.
Jinou metodou je použití třídy Collections, která poskytuje metodu ‚reverse ', která se používá ke zrušení kolekce.
Níže je uveden program pro obrácení ArrayList pomocí třídy Collections.
import java.io.*; import java.util.*; public class Main { public static void main(String() args) { // create and initialize an ArrayList ArrayList oddList = new ArrayList(); oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); System.out.print('Initial ArrayList: ' + oddList); // use Collections.reverse method to reverse the ArrayList Collections.reverse(oddList); //print the ArrayList System.out.print('
Reversed ArrayList: ' + oddList); } }
Výstup:
Initial ArrayList: (1, 3, 5, 7, 9)
Seznam obráceného pole: (9, 7, 5, 3, 1)
Odeberte duplikáty ze seznamu ArrayList v Javě
Chcete-li odebrat duplikáty z ArrayList, můžete se znovu uchýlit k tradiční metodě použití iterátoru k procházení ArrayList a uložení pouze prvního výskytu prvku do jiného ArrayList.
Ještě další metoda spočívá v použití metody ‘different ()‘ třídy stream (). Tato metoda vrací proud odlišných prvků. Funkce stream () je k dispozici v Javě od Java 8 a dále.
Níže je uvedena implementace metody stream () .distinct ():
import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { // Create an ArrayList of numbers ArrayList numList = new ArrayList (Arrays.asList(1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)); //print the original ArrayList System.out.println('Original ArrayList:' + numList); //Use Java 8 stream().distinct() method to remove duplicates from the list List distinctList = numList.stream().distinct().collect(Collectors.toList()); //print the new list System.out.println('ArrayList without duplicates:' + distinctList); } }
Výstup:
Original ArrayList: (1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)
ArrayList bez duplikátů: (1, 2, 3, 5, 6, 7, 8)
Shuffle (Randomize) Seznam Array v Javě
Můžete také „zamíchat“ nebo náhodně vybrat prvky ArrayList. To se provádí pomocí metody Collections.shuffle (). Pomocí této metody můžete buď zamíchat ArrayList s výchozím nastavením, nebo poskytnout funkci random (), která náhodně rozdělí prvky podle poskytnuté náhodné hodnoty.
Program Java k dosažení tohoto cíle je uveden níže.
import java.util.*; public class Main { public static void main(String() args) { //create and initialize a String ArrayList ArrayList strlist = new ArrayList(); strlist.add('east'); strlist.add('west'); strlist.add('north'); strlist.add('south'); strlist.add('southwest'); strlist.add('northeast'); //print the original list System.out.println('Original ArrayList :
' + strlist); //shuffle the ArrayList without random function Collections.shuffle(strlist); System.out.println('
Shuffled ArrayList without Random() :
' + strlist); // shuffle the ArrayList with random() function Collections.shuffle(strlist, new Random()); System.out.println('
Shuffled ArrayList with Random() :
' + strlist); // use random (2) to shuffle the ArrayList Collections.shuffle(strlist, new Random(2)); System.out.println('
Shuffled ArrayList with Random(2) :
' + strlist); } }
Výstup:
Original ArrayList: (východ, západ, sever, jih, jihozápad, severovýchod) Shuffled ArrayList bez Random (): (sever, severovýchod, východ, jihozápad, jih, západ)
Shuffled ArrayList with Random (): (jih, východ, sever, severovýchod, západ, jihozápad)
Shuffled ArrayList with Random (2): (jihozápad, jih, východ, severovýchod, sever, západ)
Často kladené otázky
Otázka č. 1) Jaký je rozdíl mezi homogenními a heterogenními kontejnery v Javě?
Odpovědět: Homogenní kontejnery obsahují objekty / prvky stejného typu. Na druhé straně mají heterogenní kontejnery objekty smíšeného typu.
Otázka č. 2) Je ArrayList v Javě heterogenní?
Odpovědět: Ano. Vzhledem k tomu, že ArrayLists podporují generika, a proto mazání typu, může obsahovat smíšené objekty při implementaci jako obecný ArrayList.
Otázka č. 3) Může ArrayList ukládat int?
Odpovědět: Ne. ArrayLists nemůže ukládat hodnoty jako int, ale může ukládat celočíselné objekty, protože ArrayLists může obsahovat pouze objekty. Chcete-li tedy uložit primitivní typy, měli byste použít třídy obálky jako Integer pro ints.
Otázka č. 4) Co se stane, když je ArrayList plný?
Odpovědět: Každý objekt ArrayList má funkci nazvanou „kapacita“. Když je ArrayList plný, kapacita ArrayList se automaticky zvyšuje, aby se vytvořil prostor pro další prvky.
Otázka č. 5) Jaký je rozdíl mezi metodou removeAll a keepAll v ArrayList?
Odpovědět: Metody ArrayList „removeAll“ a „keepAll“ vykazují opačné chování.
Zatímco metoda removeAll odebere všechny prvky ze seznamu, které odpovídají kolekci předané jako argument této metodě, keepAll si na druhé straně zachová všechny prvky v seznamu, které se shodují s prvky kolekce.
Závěr
V tomto kurzu jsme podrobně diskutovali metody ArrayList s příkladem.
Zvažovali jsme také některé speciální případy, jako je přidání prvků do přední části seznamu. Také jsme diskutovali o dalších operacích na ArrayList, jako je třídění, obrácení a míchání ArrayList.
V našem nadcházejícím tutoriálu probereme některé převody ArrayList.
=> Dávejte pozor na jednoduchou sérii školení Java zde.
Doporučené čtení
- Výukový program Java Reflection s příklady
- Výukový program Java String | Metody řetězců Java s příklady
- Metody seznamu Java - Řazení seznamu, Obsahuje, Přidat seznam, Seznam odebrat
- Java ArrayList - Jak deklarovat, inicializovat a vytisknout seznam ArrayList
- Převody Java ArrayList na jiné sbírky
- Výukový program Java SWING: Kontejner, komponenty a zpracování událostí
- Obrátit pole v Javě - 3 metody s příklady
- Výukový program JAVA pro začátečníky: 100+ praktických výukových programů Java Video