Metode ArrayList v Javi

arraylist methods java tutorial with example programs

Preizkusite Naš Instrument Za Odpravo Težav

Izberite Operacijski Sistem Izberite Program Projekcije (Neobvezno)

Opišite Svoj Problem

V tej vadnici bomo s primeri razpravljali o metodah Java ArrayList, kot so add, addAll, odstranitev, removeAll, velikost, vsebuje, retainAll, Sort, Reverse itd.:

V prejšnji vadnici smo raziskali podatkovno strukturo ArrayList in razred ArrayList je zagotovil to podatkovno strukturo / zbirko v Javi. Naučili smo se ustvarjanja, inicializacije itd. Objektov ArrayList.

Razen teh funkcij, ki nam pomagajo določiti ArrayList, razred ArrayList v Javi ponuja tudi polnopravni API funkcije, ki je sestavljen iz metod, ki se uporabljajo za manipulacijo objektov ArrayList.

=> Tukaj preverite VSE Vadnice za Java.

Te metode nam omogočajo dodajanje, brisanje, iskanje elementov v ArrayList ter pridobivanje dolžine / velikosti elementov ArrayList itd.

Java ArrayList_Methods

V tej vadnici bomo te metode podrobno obravnavali s preprostimi primeri programiranja.

Kaj se boste naučili:

Naslednja tabela navaja vse metode, ki jih nudi razred ArrayList.

Metoda	Prototip metode	Opis metode
Vsebuje	logična vrednost vsebuje (predmet o)	Preveri, ali seznam vsebuje dani element „o“. Vrne true, če je element prisoten.
Dodaj	logični dodatek (E e)	Dodan element e doda na konec seznama.
Dodaj	void add (int index, E element)	Doda dani element ‘element’ na določenem položaju ‘indeks’.
AddAll	boolean addAll (zbirka c)	Doda vse elemente v dani zbirki c na konec seznama.
AddAll	logični addAll (indeks int, zbirka c)	Doda vse elemente v dani zbirki c na mestu, ki ga določa ‘indeks’ na seznamu.
Jasno	prazno jasno ()	Počisti seznam tako, da s seznama odstrani vse elemente.
Klon	Klon predmeta ()	Naredi plitvo kopijo danega seznama ArrayList.
zagotovitiCapacity	void secureCapacity (int minCapacity)	Poveča zmogljivost ArrayList, da zagotovi minCapacity.
Pojdi	E get (indeks int)	Vrne element na seznamu, ki je prisoten na položaju, ki ga določa 'indeks'.
indeks	int indexOf (predmet o)	Vrne indeks prvega pojavljanja elementa o na seznamu. -1, če element o ni na seznamu.
je prazno	logična isEmpty ()	Preveri, ali je dani seznam prazen.
Iterator	Iterator iteratorja ()	Vrne iterator za prehod po elementih seznama v ustreznem zaporedju.
lastIndexOf	int lastIndexOf (Predmet o)	Vrne indeks zadnjega pojavljanja podanega elementa o na seznamu. -1, če element ni prisoten na seznamu.
listIterator	ListIterator listIterator ()	Vrne iterator seznama za prehod po elementih danega seznama.
listIterator	ListIterator listIterator (indeks int)	Vrne iterator seznama, začenši z določenega položaja 'indeks', da prečka elemente danega seznama.
Odstrani	E odstrani (indeks int)	Izbriše element v indeksu v seznamu ArrayList.
Odstrani	logično odstranjevanje (objekt o)	Izbriše prvi pojav elementa o s seznama.
odstrani vse	boolean removeAll (zbirka c)	Odstrani vse elemente s seznama, ki se ujemajo z elementi v dani zbirki c.
removeRange	zaščitena praznina removeRange (int fromIndex, int toIndex)	S seznama odstrani elemente, podane v danem obsegu, odIndex (vključno) do toIndex (izključno).
retainAll	boolean retainAll (zbirka c)	Obdrži tiste elemente na seznamu, ki se ujemajo z elementi v dani zbirki c.
nastavite	E set (indeks int, element E)	Nastavi vrednost elementa v danem ‘indeksu’ na novo vrednost, ki jo poda ‘element’.
velikost	velikost int ()	Vrne skupno število elementov ali dolžino seznama.
subList	Seznam seznamov (int fromIndex, int toIndex)	Vrne podlistk med danim obsegom, odIndex do toIndex za dani seznam.
toArray	Object () toArray ()	Pretvori dani seznam v matriko.
toArray	T () doArray (T () a)	Pretvori dani seznam v polje vrste, ki jo poda a.
trimToSize	void trimToSize ()	Zmogljivost ArrayList obreže na velikost ali število elementov, prisotnih na seznamu.

Nato bomo podrobno obravnavali vsako od teh metod iz API-ja funkcije ArrayList in predstavili primere programiranja. Po razpravi o vseh zgoraj naštetih metodah bomo obravnavali tudi nekatere posebne operacije, ki se izvajajo z uporabo seznamov ArrayLists, ki niso del API-ja funkcije ArrayList.

ArrayList add

jaz

Prototip: logični dodatek (E e)
Parametri: e => Element, ki ga je treba dodati na seznam ArrayList.
Vrnjena vrednost: true => Element je bil uspešno dodan.
Opis: Dani element e doda na konec seznama.

II.

Prototip: void add (int index, E element)

Parametri:

index => Položaj, na katerem naj se doda element.
Element => Element, ki ga je treba dodati na seznam ArrayList.

Vrnjena vrednost: praznino

Opis: Doda dani element ‘element’ na določenem položaju ‘indeks’ s premikom elementa na tem položaju in nadaljnjih elementov v desno.

Izjeme: IndexOutOfBoundsException => Če je navedeni indeks zunaj obsega.

ArrayList addAll

jaz

Prototip: boolean addAll (zbirka c)
Parametri: c => Zbirka, katere elemente je treba dodati v ArrayList.
Vrnjena vrednost: true => Če je operacija spremenila ArrayList.

Opis: Doda vse elemente v dani zbirki c na konec seznama. Rezultat operacije je nedoločen, če se zbirka spremeni, ko je operacija v teku.

Izjeme: NullPointerException => Če je podana zbirka c nična.

Prototip: logični addAll (indeks int, zbirka c)
Parametri: index => Položaj, na katerem je treba dodati elemente v dani zbirki.
Vrnjena vrednost: true => Če se je seznam spremenil zaradi operacije.

Opis: Doda vse elemente v dani zbirki c na mestu, ki ga določa ‘indeks’ na seznamu. Element pri določenem indeksu in nadaljnji elementi se premaknejo v desno. Rezultat operacije je nedoločen, če se dodana zbirka spremeni, ko je operacija v teku.

Izjeme: IndexOutOfBoundsException: če je indeks, kamor naj se doda zbirka, zunaj meja
NullPointerException: če je podana zbirka c nična.

Naslednji program Java prikazuje uporabo metod add in 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); } }

Izhod:

Začetni seznam array: (Delhi, Mumbai, Chennai, Kolkata)
rrayList po dodajanju elementa v indeksu 1: (Delhi, NYC, Mumbai, Chennai, Kolkata)
ArrayList po dodajanju seznama pri indeksu 4: (Delhi, New York, Mumbai, Chennai, Pune, Hyderabad, Kolkata)

Izhod iz Java ArrayList addAll

Zgornji program uporablja obe različici metode add za dodajanje elementov na seznam. Prav tako doda zbirko na seznam z določenim indeksom. Upoštevajte premike elementov na desno od seznama ArrayList, kar je razvidno iz rezultata programa.

ArrayList Dodaj na sprednjo stran

Kot smo že omenili, prva različica metode add doda elemente na konec seznama. Če želite elemente dodati na začetku seznama ArrayList, morate uporabiti drugo različico metode add. Ta metoda dodajanja kot parameter vzame indeks. Ta indeks je položaj, na katerem bo element dodan.

Če želite element dodati na začetek seznama, morate indeks določiti kot 0, kar je začetek seznama.

Naslednji program doda element na sprednji del seznama 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); } }

Izhod:

Začetni seznam array:
(5, 7, 9)
ArrayList po dodajanju elementov na začetku:
(1, 3, 5, 7, 9)

Izhod - ArrayList dodaj spredaj

ArrayList odstrani

JAZ.

brezplačna programska oprema za upravljanje cerkva polna različica

Prototip: E odstrani (indeks int)
Parametri: index => Položaj, na katerem naj se element odstrani s seznama ArrayList.
Vrnjena vrednost: E => Element, ki se izbriše
Opis: Izbriše element v indeksu v seznamu ArrayList in premakne naslednje elemente v levo.
Izjeme: IndexOutOfBoundsException => Navedeni indeks je izven obsega.

II.

Prototip: logično odstranjevanje (objekt o)
Parametri: o => Element, ki ga je treba odstraniti s seznama ArrayList.
Vrnjena vrednost: true => Če je element prisoten na seznamu.

Opis: Izbriše prvi pojav elementa o s seznama. Če element ni na seznamu, potem ta operacija ne vpliva. Ko je element izbrisan, se naslednji elementi premaknejo v levo.

ArrayList removeAll

Prototip: boolean removeAll (zbirka c)
Parametri: c => Zbirka, katere elementi se ujemajo z elementi ArrayList in jih je treba odstraniti.
Vrnjena vrednost: true => Če operacija spremeni ArrayList.

Opis: Odstrani vse elemente s seznama, ki se ujemajo z elementi v dani zbirki c. Posledično se preostali elementi premaknejo levo na seznam.

Izjeme: ClassCastException => Razred ni enak razredu določene zbirke, kar pomeni, da je razred nezdružljiv.
NullPointerException => Če je podana zbirka c nična; ali če ima c null element in zbirka tega ne dovoli.

ArrayList removeRange

Prototip: zaščitena praznina removeRange (int fromIndex, int toIndex)
Parametri: fromIndex => Kazalo začetnega elementa obsega, ki ga je treba odstraniti.
toIndex => Kazalo elementa po zadnjem elementu v obsegu, ki ga je treba odstraniti.
Vrnjena vrednost: praznino
Opis: S seznama odstrani elemente, podane v danem obsegu, odIndex (vključno) do toIndex (izključno). Ta operacija skrajša dolžino seznama za (toIndex-fromIndex). Ta operacija nima učinka v primeru odIndex = doIndex.
Izjeme: IndexOutOfBoundsException => Če je kateri koli indeks (fromIndex ali toIndex) zunaj meja.

Izvedimo program Java, da predstavimo nekatere od teh metod odstranjevanja, ki smo jih obravnavali zgoraj.

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); } }

Izhod:

Začetni seznam array: (Delhi, Mumbai, Chennai, Kolkata, Pune, Hyderabad
ArrayList po odstranitvi elementa pri indeksu 2: (Delhi, Mumbai, Kolkata, Pune, Hyderabad)
ArrayList po odstranitvi elementa -> Kolkata: (Delhi, Mumbai, Pune, Hyderabad)
ArrayList po klicu za odstranitevVse: (Mumbai, Puna)

Izhod - ArrayList removeAll range

Velikost seznama array (dolžina)

Prototip: velikost int ()
Parametri: NIL
Vrnjena vrednost: int => Število elementov v seznamu ArrayList.
Opis: Vrne skupno število elementov ali dolžino seznama ArrayList.

EnsureCapacity

Prototip: void secureCapacity (int minCapacity)
Parametri: minCapacity => Najmanjša zmogljivost, ki jo želimo za ArrayList.
Vrnjena vrednost: praznino
Opis: Poveča zmogljivost ArrayList, da zagotovi minCapacity.

trimToSize

Prototip: void trimToSize ()
Parametri: NIL
Vrnjena vrednost: praznino
Opis: Zmogljivost ArrayList obreže na velikost ali število elementov, prisotnih na seznamu.

Spodnji primer programiranja prikazuje metode velikosti (), zagotovitiCapacity () in 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 + ' '); } } }

Izhod:

Začetna velikost: 0
Izvirni seznam: (2, 4, 6, 8, 10)
Velikost arrayList po operaciji dodajanja: 5
Velikost arrayList po klicu »dodajCapacity () in dodajanje: 7
Velikost ArrayList po operaciji trimToSize (): 7
ArrayList final:
2 4 6 8 10 12 14

Izhod - Velikost seznama array (dolžina)

ArrayList vsebuje

Prototip: logična vrednost vsebuje (predmet o)
Parametri: o => Element, ki ga je treba preveriti, če je prisoten v ArrayList.
Vrnjena vrednost: true => Če ArrayList vsebuje element o.
Opis: Preveri, ali seznam vsebuje dani element „o“. Vrne true, če je element prisoten.

V naslednjem programu uporabljamo metodo ‘vsebuje’.

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')); } }

Izhod:

ArrayList vsebuje ('Red Green'): false
ArrayList vsebuje (‘Blue’): true
ArrayList vsebuje (‘Yellow’): false
ArrayList vsebuje (‘White’): true

Izhod - ArrayList vsebuje

Kot je prikazano v zgornjem izhodu, metoda ‘contains’ preveri, ali je navedeni argument prisoten v ArrayList in vrne true ali false.

ArrayList get

Prototip: E get (indeks int)
Parametri: index => Indeks, pri katerem elementu je treba pridobiti s seznama ArrayList.
Vrnjena vrednost: E => Vrednost elementa pri danem indeksu v ArrayList.
Opis: Vrne element na seznamu, ki je prisoten na položaju, ki ga določa 'indeks'.
Izjeme: IndexOutOfBoundsException => Če je indeks zunaj meja.

ArrayList set (Replace element)

Prototip: E set (indeks int, element E)
Parametri: index => Kazalo, pri katerem bo element zamenjan.
Element => Nov element, ki se nastavi na določen indeks.
Vrnjena vrednost: E => Element, ki ga nadomesti nastavljena operacija.
Opis: Nastavi vrednost elementa v danem 'indeksu' na novo vrednost, ki jo poda 'element'.
Izjeme: IndexOutOfBoundsException => Če je indeks zunaj meja

Spodnji program Java uporablja metodo get () in set () za pridobivanje in zamenjavo vrednosti 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)); } }

Izhod:

Vnos v indeksu 2 pred klicem za nastavitev: modra
Vnos v indeksu 2 po klicu za nastavitev: rumena

Izhod

ArrayList clear

Prototip: prazno jasno ()
Parametri: NIL
Vrnjena vrednost: praznino
Opis: Počisti seznam tako, da s seznama odstrani vse elemente.

ArrayList isEmpty

Prototip: logična isEmpty ()
Parametri: NIL
Vrnjena vrednost: true => če je seznam prazen
Opis: Preveri, ali je dani seznam prazen.

Spodaj so prikazane funkcije Clear () in isEmpty ().

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()); } }

Izhod:

Seznam array: (rdeča, zelena, modra, bela)
Ali je ArrayList prazen po clear ()? :prav

Izhod - isEmpty ArrayList

ArrayList indexOf

Prototip: int indexOf (predmet o)
Parametri: o => Element, katerega indeks najdemo v ArrayList.
Vrnjena vrednost: int => Kazalo prvega pojavljanja elementa na seznamu.
Opis: Vrne indeks prvega pojavljanja elementa o na seznamu. -1, če element o ni na seznamu.

ArrayList lastIndexOf

Prototip: int lastIndexOf (Predmet o)
Parametri: o => Element, ki ga želite iskati.
Vrnjena vrednost: int => Kazalo zadnjega pojavljanja elementa na seznamu.
Opis: Vrne indeks zadnjega pojavljanja podanega elementa o na seznamu. -1, če element ni prisoten na seznamu.

Spodnji program Java prikazuje metode indexOf in lastIndexOf 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)); } }

Izhod:

ArrayList: (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
indeksOf (5): 4
lastIndexOf (5): 4

Izhod

ArrayList toArray

Prototip: Object () toArray ()
Parametri: NIL
Vrnjena vrednost: Objekt () => matrika. Ta vrnjena matrika vsebuje vse elemente seznama v pravilnem zaporedju.
Opis: Pretvori dani seznam v matriko.

Prototip: T () doArray (T () a)

Parametri: a => Polje za shranjevanje elementov seznama. Če velikost polja ni dovolj za elemente seznama, se za shranjevanje elementov ustvari drugo polje istega tipa kot a.

Vrnjena vrednost: T () => Matrika, ki vsebuje vse elemente seznama.
Opis: Pretvori dani seznam v polje vrste, ki jo poda a.

Izjeme: ArrayStoreException => Če obstaja vrsta neusklajenosti vrste izvedbe polja in vrste izvajanja ali nadtipa njegovih elementov.
NullPointerException => Podana matrika je nična

Spodnji program Java prikazuje metodo toArray za 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)); } }

Izhod:

ArrayList: (10, 20, 30, 40, 50)
Polje iz ArrayList: (10, 20, 30, 40, 50)

Izhod - toArray ArrayList

Klon ArrayList

Prototip: Klon predmeta ()
Parametri: NIL
Vrnjena vrednost: Objekt => Klon primerka ArrayList.
Opis: Naredi plitvo kopijo danega seznama 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); } }

Izhod:

Original ArrayList: (jabolko, pomaranča, melona, grozdje)
Klonirani seznam vrst: (jabolko, oranžna, melona, grozdje)
Original ArrayList po dodajanju in odstranjevanju: (jabolko, melona, grozdje, mango)
Cloned ArrayList po spremembi izvirnika: (Apple, Orange, Melon, Grapes)

izhod - klon arraylist

Iz zgornjega izhoda programa lahko vidite, da je klonirani ArrayList plitva kopija prvotnega ArrayList. To pomeni, da se ob spremembi prvotnega seznama ArrayList te spremembe ne odražajo v kloniranem seznamu ArrayList, saj si ne delijo pomnilniških mest vsakega elementa.

Za izdelavo globoke kopije Array je treba prehoditi izvirni ArrayList in kopirati vse njegove elemente v ciljni ArrayList.

ArrayList subList

Prototip: Seznam seznamov (int fromIndex, int toIndex)
Parametri: fromIndex => Začetni indeks obsega (vključno)
toIndex => Končni indeks obsega (izključno)
Vrnjena vrednost: Seznam => Sublist seznama v danem obsegu.

Opis: Vrne podlistk med danim obsegom, od Indexa do indeksa za dani seznam. Upoštevajte, da ta podlist ali pogled seznama v danem obsegu podpira vse operacije, ki jih seznam podpira. Pogled ni vrnjen, če je fromIndex = toIndex.

Izjeme: IndexOutOfBoundsException => Vrženo, ko je toIndex zunaj dosega.
IllegalArgumentException => Če fromIndex> toIndex, torej indeksi niso v redu.

Oglejmo si primer metode 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); } }

Izhod:

Original ArrayList: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
Podlistki danega seznama ArrayList: (15, 20, 25, 30)

Izhod

ArrayList retainAll

Prototip: boolean retainAll (zbirka c)
Parametri: c => Zbirka z elementi, ki jih je treba obdržati na seznamu.
Vrnjena vrednost: true => Če se je ArrayList spremenil kot rezultat operacije.
Opis: Obdrži tiste elemente na seznamu, ki se ujemajo z elementi v dani zbirki c.

preizkusite mojo spletno stran v različnih brskalnikih

Izjeme: ClassCastException => Vrsta zbirke in vrsta seznama se ne ujemata
NullPointerException => Dana zbirka je nična ali seznam vsebuje ničelni element, zbirka pa ne dovoljuje ničelnih vrednosti.

Naslednji program prikazuje metodo retainAll.

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); } }

Izhod:

Original ArrayList: (rdeča, zelena, modra, rumena)
Elementi zbirke, ki jih je treba obdržati na seznamu: (rdeča, modra)
ArrayList after retainAll call: (Red, Blue)

Izhod - maloprodajaVsa metoda

ArrayList Iterator

Prototip: Iterator iteratorja ()
Parametri: NIL
Vrnjena vrednost: Iterator => iterator nad elementi seznama.
Opis: Vrne iterator za prehod po elementih seznama v ustreznem zaporedju.

ArrayList listIterator

JAZ.

Prototip: ListIterator listIterator ()
Parametri: NIL
Vrnjena vrednost: ListIterator => listIterator nad elementi seznama.
Opis: Vrne iterator seznama za prehod po elementih danega seznama.

II.

Prototip: ListIterator listIterator (indeks int)
Parametri: index => Položaj prvega elementa v listIterator.
Vrnjena vrednost: ListIterator => ListIterator za seznam iz določenega indeksa.
Opis: Vrne iterator seznama, začenši z določenega položaja 'indeks', da prečka elemente danega seznama.
Izjeme: IndexOutOfBoundsException => Dani indeks je izven obsega.

Primer metod iterator () in 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() + ' '); } } }

Izhod:

Vsebina seznama z uporabo metode Iterator ():
Mumbai Pune Hyderabad Delhi
Vsebina seznama z metodo listIterator ():
Mumbai Pune Hyderabad Delhi

Izhod - metode Iterator in listIterator

Dodaj polje ArrayList v Javi

ArrayList podpira metodo addAll za dodajanje elementov zbirke v ArrayList. Na podoben način lahko ArrayListu dodate tudi Array. To se naredi z metodo ‘Collections.addAll’.

Primer dodajanja polja 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); } }

Izhod:

Začetni seznam array: (Delhi, Mumbai, Chennai, Kolkata)
ArrayList po dodajanju polja: (Delhi, Mumbai, Chennai, Kolkata, Cochin, Goa)

output - Dodaj matriko v Arraylist v Javi

Razvrsti ArrayList v Javi

ArrayList za razvrščanje svojih elementov uporablja metodo Collections.sort. Seznam je privzeto razvrščen po naraščajočem vrstnem redu po metodi Collections.sort. Če želite razvrstiti ArrayList v padajočem vrstnem redu, morate metodi razvrščanja navesti parameter »Collections.reverseOrder ()«.

Spodaj je program za razvrščanje seznama ArrayList v naraščajočem in padajočem vrstnem redu:

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); } }

Izhod:

Začetni seznam nizov: (rdeča, zelena, modra, rumena)
ArrayList razvrščen po naraščajočem vrstnem redu:
(Modra, zelena, rdeča, rumena)
ArrayList razvrščen po padajočem vrstnem redu:
(Rumena, Rdeča, Zelena, Modra)

Izhod - razvrsti seznam arraylist v Javi

Če ArrayList kot elemente vsebuje druge predmete razreda, lahko uporabite vmesnika Comparable in Comparator. Več podrobnosti o vmesnikih bo zajetih v naših kasnejših vadnicah.

Povratni seznam array v Javi

ArrayList lahko tudi obrnete v Javi. Eden od načinov za to je uporaba tradicionalne metode prečkanja ArrayList v obratnem vrstnem redu in kopiranje vsakega elementa v nov ArrayList.

Druga metoda je uporaba razreda Collections, ki zagotavlja metodo 'reverse', ki se uporablja za obrnitev zbirke.

Program za razveljavitev seznama ArrayList z uporabo razreda Zbirke je podan spodaj.

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); } }

Izhod:

Začetni seznam array: (1, 3, 5, 7, 9)
Obrnjen seznam matrik: (9, 7, 5, 3, 1)

Izhod - Reverse in ArrayList

Odstranite dvojnike s seznama array v Javi

Če želite odstraniti dvojnike iz seznama ArrayList, se lahko ponovno zatečete k tradicionalni metodi uporabe iteratorja za prehod skozi seznam ArrayList in shranite samo prvi pojav elementa v drug ArrayList.

Še ena metoda je z uporabo metode 'distinct ()' razreda stream (). Ta metoda vrne tok različnih elementov. Funkcija stream () je na voljo v Javi od Jave 8 naprej.

Izvedba metode stream () .distinct () je podana spodaj:

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); } }

Izhod:

Original ArrayList: (1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)
ArrayList brez dvojnikov: (1, 2, 3, 5, 6, 7, 8)

Izhod - odstranite dvojnike iz seznama ArrayList

Premešaj (naključno) seznam array v Javi

Elemente ArrayList lahko tudi »premešate« ali naključno prilagodite. To se naredi z uporabo metode Collections.shuffle (). S to metodo lahko ArrayList premešate s privzetimi nastavitvami ali pa zagotovite funkcijo random (), ki bo elemente naključno razvrstila glede na naključno vrednost.

Program Java za dosego tega je podan spodaj.

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); } }

Izhod:

Original ArrayList: (vzhod, zahod, sever, jug, jugozahod, severovzhod) Premeščen ArrayList brez naključnega (): (sever, severovzhod, vzhod, jugozahod, jug, zahod)
Premeščen seznam matrik z naključnimi (): (jug, vzhod, sever, severovzhod, zahod, jugozahod)
Premeščen seznam array z naključnimi (2): (jugozahod, jug, vzhod, severovzhod, sever, zahod)

Izhod - premešajte (naključno) ArrayList

Pogosto zastavljena vprašanja

V # 1) Kakšna je razlika med homogenimi in heterogenimi vsebniki v Javi?

Odgovor: Homogeni vsebniki vsebujejo predmete / elemente iste vrste. Po drugi strani pa imajo heterogeni zabojniki predmete mešanega tipa.

Q # 2) Ali je ArrayList v Javi heterogen?

Odgovor: Da. Ker ArrayLists podpirajo generične in s tem izbris tipa, lahko vsebuje mešane predmete, kadar je implementiran kot generični ArrayList.

3. vprašanje) Ali lahko ArrayList shrani int?

Odgovor: Ne. ArrayLists ne more shraniti vrednosti, kot je int, lahko pa predmete Integer, saj lahko ArrayLists vsebuje samo predmete. Tako za shranjevanje primitivnih tipov za inte uporabite razrede ovitkov, kot je Integer.

V # 4) Kaj se zgodi, ko je ArrayList poln?

Odgovor: Vsak objekt ArrayList ima funkcijo z imenom 'zmogljivost'. Ko je ArrayList poln, se zmogljivost ArrayList samodejno poveča, da se sprosti prostor za več elementov.

V # 5) Kakšna je razlika med metodo removeAll in retainAll v ArrayList?

Odgovor: Metodi ArrayList 'removeAll' in 'retainAll' kažeta nasprotno vedenje.

Medtem ko metoda removeAll s seznama odstrani vse elemente, ki se ujemajo z zbirko, posredovano kot argument tej metodi, pa retainAll po drugi strani ohrani vse elemente na seznamu, ki se ujemajo z elementi zbirke.

Zaključek

V tej vadnici smo s primerom podrobno obravnavali metode ArrayList.

Upoštevali smo tudi nekaj posebnih primerov, kot je dodajanje elementov na sprednji del seznama. Razpravljali smo tudi o drugih operacijah na ArrayList, kot so razvrščanje, vzvratno spreminjanje in mešanje ArrayList.

V naši prihajajoči vadnici bomo razpravljali o nekaterih pretvorbah ArrayList.

=> Tukaj si oglejte preproste vadbene serije Java.

Metode ArrayList v Javi - Vadnica s primeri programov