ArrayList-metoder i Java

arraylist methods java tutorial with example programs

mp3 musik downloader app til android

Prøv Vores Instrument Til At Fjerne Problemer

Vælg Operativsystemet Vælg Et Projektionsprojekt (Valgfrit)

Beskriv Dit Problem

I denne vejledning diskuterer vi Java ArrayList-metoder som tilføj, tilføjAlle, fjern, fjernAlle, størrelse, indeholder, beholderAlle, Sorter, omvendt osv. Med eksempler:

I den foregående vejledning undersøgte vi ArrayList-datastrukturen, og ArrayList-klassen sørgede for denne datastruktur / samling i Java. Vi har lært oprettelse, initialisering osv. Af ArrayList-objekterne.

Bortset fra disse funktioner, der hjælper os med at definere ArrayList, leverer ArrayList-klassen i Java også en fuldgyldig funktions-API, der består af metoder, der bruges til at manipulere ArrayList-objekter.

=> Tjek ALLE Java-tutorials her.

Disse metoder giver os mulighed for at tilføje, slette, søge elementer i ArrayList samt at hente længden / størrelsen på ArrayList-elementer osv.

Java ArrayList_Methods

I denne vejledning vil vi diskutere disse metoder detaljeret med enkle programmeringseksempler.

Hvad du lærer:

Følgende tabel viser alle de metoder, der leveres af ArrayList-klassen.

Metode	Metode Prototype	Metode Beskrivelse
Indeholder	boolsk indeholder (Objekt o)	Kontrollerer, om listen indeholder det givne element 'o'. Returnerer sandt, hvis elementet er til stede.
Tilføje	boolsk tilføjelse (E e)	Tilføjer givet element e til slutningen af listen.
Tilføje	ugyldig tilføjelse (int-indeks, E-element)	Tilføjer det givne element 'element' på den angivne position 'indeks'.
Tilføj alle	boolsk addAll (samling c)	Tilføjer alle elementerne i den givne samling c til slutningen af listen.
Tilføj alle	boolsk addAll (int-indeks, samling c)	Tilføjer alle elementerne i den givne samling c på den position, der er angivet af 'indekset' på listen.
Klar	ugyldigt klart ()	Rydder listen ved at fjerne alle elementerne fra listen.
Klon	Objektklon ()	Opretter en lav kopi af den givne ArrayList.
sikre kapacitet	ugyldig sikre kapacitet (int min kapacitet)	Øger ArrayListens kapacitet for at sikre, at den har minCapacity.
Få	E get (int-indeks)	Returnerer elementet på listen til stede på den position, der er angivet af 'indeks'.
indeks af	int indexOf (Objekt o)	Returnerer indekset for den første forekomst af element o på listen. -1 hvis element o ikke er til stede på listen.
er tom	boolsk isEmpty ()	Kontrollerer, om den givne liste er tom.
Iterator	Iterator iterator ()	Returnerer en iterator til at krydse over listeelementerne i den rigtige rækkefølge.
lastIndexOf	int lastIndexOf (Objekt o)	Returnerer indekset for den sidste forekomst af det angivne element o på listen. -1 hvis elementet ikke er til stede på listen.
listIterator	ListIterator listIterator ()	Returnerer liste iterator til at krydse over elementerne i den givne liste.
listIterator	ListIterator listIterator (int index)	Returnerer listen iterator startende fra den angivne position 'indeks' for at krydse over elementerne i den givne liste.
fjerne	E fjern (int-indeks)	Sletter elementet ved 'indekset' i ArrayList.
fjerne	boolsk fjernelse (Objekt o)	Sletter den første forekomst af element o fra listen.
Fjern alt	boolsk removeAll (samling c)	Fjerner alle de elementer fra listen, der matcher elementerne i den givne samling c.
removeRange	beskyttet tomrum removeRange (int fraIndex, int tilIndex)	Fjerner elementer, der er specificeret i det givne interval, fraIndex (inklusive) tilIndex (eksklusiv) fra listen.
bevar alle	boolean retainAll (Collection c)	Beholder de elementer på listen, der matcher elementerne i den givne samling c.
sæt	E-sæt (int-indeks, E-element)	Indstiller elementværdien ved det givne 'indeks' til den nye værdi, der gives med 'elementet'.
størrelse	int størrelse ()	Returnerer det samlede antal elementer eller længden på listen.
underliste	Liste underliste (int fraIndex, int tilIndex)	Returnerer en underliste mellem det givne interval, fra index til index for den givne liste.
toArray	Objekt () toArray ()	Konverterer den givne liste til en matrix.
toArray	T () til Array (T () a)	Konverterer den givne liste til en matrix af typen angivet med a.
trimToSize	ugyldig trimToSize ()	Trimmer ArrayList-kapaciteten til størrelsen eller antallet af elementer, der findes på listen.

Dernæst vil vi diskutere hver af disse metoder fra ArrayList-funktion API i detaljer og præsentere programmeringseksempler. Efter at have diskuteret alle de ovennævnte metoder, vil vi også tage nogle specifikke operationer op, der udføres ved hjælp af ArrayLists, som ikke er en del af ArrayList-funktion API.

ArrayList tilføj

jeg

Prototype: boolsk tilføjelse (E e)
Parametre: e => Element, der skal føjes til ArrayList.
Returværdi: true => Element tilføjet.
Beskrivelse: Tilføjer det givne element e til slutningen af listen.

II.

Prototype: ugyldig tilføjelse (int-indeks, E-element)

Parametre:

index => Position, hvor elementet skal tilføjes.
Element => Element, der skal føjes til ArrayList.

Returværdi: ugyldig

Beskrivelse: Tilføjer det givne element 'element' ved den angivne position 'indeks' ved at flytte elementet ved denne position og efterfølgende elementer til højre.

Undtagelser: IndexOutOfBoundsException => Hvis det angivne indeks er uden for området.

ArrayList addAll

jeg

Prototype: boolsk addAll (samling c)
Parametre: c => Samling, hvis elementer skal føjes til ArrayList.
Returværdi: true => Hvis handlingen har ændret ArrayList.

Beskrivelse: Tilføjer alle elementerne i den givne samling c til slutningen af listen. Resultatet af operationen er udefineret, hvis indsamlingen ændres, når operationen er i gang.

Undtagelser: NullPointerException => Hvis given samling c er nul.

Prototype: boolsk addAll (int-indeks, samling c)
Parametre: index => Position, hvor elementerne i den givne samling skal tilføjes.
Returværdi: true => Hvis listen er ændret som et resultat af operationen.

Beskrivelse: Tilføjer alle elementerne i den givne samling c på den position, der er angivet af 'indekset' på listen. Elementet ved det angivne indeks og efterfølgende elementer flyttes til højre. Resultatet af operationen er udefineret, hvis samlingen, der tilføjes, ændres, når operationen er i gang.

Undtagelser: IndexOutOfBoundsException: hvis indekset, hvor samlingen skal tilføjes, er uden for grænserne
NullPointerException: hvis den givne samling c er null.

Det følgende Java-program demonstrerer brugen af add and addAll-metoder.

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

Produktion:

Indledende ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
rrayList efter tilføjelse af element i indeks 1: (Delhi, NYC, Mumbai, Chennai, Kolkata)
ArrayList efter tilføjelse af liste i indeks 4: (Delhi, NYC, Mumbai, Chennai, Pune, Hyderabad, Kolkata)

Output af Java ArrayList addAll

Ovenstående program bruger begge versioner af tilføjelsesmetoden til at tilføje elementer til listen. Det tilføjer også en samling til listen i det angivne indeks. Bemærk forskydningen af elementer til højre for ArrayList, som det fremgår af programmets output.

ArrayList Tilføj til fronten

Som allerede nævnt tilføjer den første version af add-metoden elementerne til slutningen af listen. Hvis du vil tilføje elementerne i starten af ArrayList, skal du bruge den anden version af add-metoden. Denne tilføjelsesmetode tager et indeks som en parameter. Dette indeks er den position, hvor elementet skal tilføjes.

For at tilføje elementet i begyndelsen af listen skal du således angive indekset som 0, som er starten på listen.

Det følgende program tilføjer et element foran 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); } }

Produktion:

Indledende ArrayList:
(5, 7, 9)
ArrayList efter tilføjelse af elementer i starten:
(1, 3, 5, 7, 9)

Output - ArrayList tilføj til fronten

Fjern ArrayList

JEG.

Prototype: E fjern (int-indeks)
Parametre: index => Position, hvor elementet skal fjernes fra ArrayList.
Returværdi: E => Element, der slettes
Beskrivelse: Sletter element ved 'indekset' i ArrayList og flytter efterfølgende elementer til venstre.
Undtagelser: IndexOutOfBoundsException => Angivet indeks er uden for området.

II.

Prototype: boolsk fjernelse (Objekt o)
Parametre: o => Element, der skal fjernes fra ArrayList.
Returværdi: true => Hvis elementet er til stede på listen.

Beskrivelse: Sletter den første forekomst af element o fra listen. Hvis elementet ikke er til stede på listen, er der ingen effekt af denne handling. Når elementet er slettet, skiftes de efterfølgende elementer til venstre.

ArrayList removeAll

Prototype: boolsk removeAll (samling c)
Parametre: c => Samling, hvis elementer matcher dem i ArrayList og skal fjernes.
Returværdi: true => Hvis ArrayList ændres af handlingen.

Beskrivelse: Fjerner alle de elementer fra listen, der matcher elementerne i den givne samling c. Som et resultat flyttes de resterende elementer til venstre på listen.

Undtagelser: ClassCastException => Klassen er ikke den samme som den specificerede samling, hvilket antyder, at klassen er inkompatibel.
NullPointerException => Hvis den givne samling c er nul; eller hvis c har et null-element, og det ikke er tilladt af samlingen.

ArrayList removeRange

Prototype: beskyttet tomrum removeRange (int fraIndex, int tilIndex)
Parametre: fromIndex => Indeks for startelementet i området, der skal fjernes.
toIndex => Elementets indeks efter det sidste element i området, der skal fjernes.
Returværdi: ugyldig
Beskrivelse: Fjerner elementer, der er specificeret i det givne interval, fraIndex (inklusive) tilIndex (eksklusiv) fra listen. Denne handling forkorter længden af listen med (toIndex-fromIndex). Denne handling har ingen effekt i tilfælde fraIndex = tilIndex.
Undtagelser: IndexOutOfBoundsException => Hvis nogen af indekserne (fraIndex eller toIndex) er uden for grænserne.

Lad os implementere et Java-program for at demonstrere nogle af disse fjernelsesmetoder, som vi diskuterede ovenfor.

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

Produktion:

Indledende ArrayList: (Delhi, Mumbai, Chennai, Kolkata, Pune, Hyderabad
ArrayList efter fjernelse af element i indeks 2: (Delhi, Mumbai, Kolkata, Pune, Hyderabad)
ArrayList efter fjernelse af element -> Kolkata: (Delhi, Mumbai, Pune, Hyderabad)
ArrayList efter opkald for at fjerneAlle: (Mumbai, Pune)

Output- ArrayList removeAll rækkevidde

ArrayList størrelse (længde)

Prototype: int størrelse ()
Parametre: NIL
Returværdi: int => Antal elementer i ArrayList.
Beskrivelse: Returnerer det samlede antal elementer eller længden på ArrayList.

Sørg for kapacitet

Prototype: ugyldig sikre kapacitet (int min kapacitet)
Parametre: minCapacity => Den ønskede minimumskapacitet for ArrayList.
Returværdi: ugyldig
Beskrivelse: Øger ArrayListens kapacitet for at sikre, at den har minCapacity.

trimToSize

Prototype: ugyldig trimToSize ()
Parametre: NIL
Returværdi: ugyldig
Beskrivelse: Trimmer ArrayList-kapaciteten til størrelsen eller antallet af elementer, der findes på listen.

Nedenstående programmeringseksempel viser metodestørrelsen (), sikreCapacity () og 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 + ' '); } } }

Produktion:

Indledende størrelse: 0
Oprindelig liste: (2, 4, 6, 8, 10)
ArrayList-størrelse efter tilføjelsesoperation: 5
ArrayList-størrelse efter sureCapacity () kald og tilføj operation: 7
ArrayList-størrelse efter trimToSize () -handling: 7
ArrayList final:
2 4 6 8 10 12 14

Output - ArrayList størrelse (længde)

ArrayList indeholder

Prototype: boolsk indeholder (Objekt o)
Parametre: o => Element, der skal kontrolleres, hvis det findes i ArrayList.
Returværdi: true => Hvis ArrayList indeholder element o.
Beskrivelse: Kontrollerer, om listen indeholder det givne element 'o'. Returnerer sandt, hvis elementet er til stede.

Vi bruger metoden 'indeholder' i det følgende program.

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

Produktion:

ArrayList indeholder (‘Red Green’): false
ArrayList indeholder ('Blå'): sandt
ArrayList indeholder ('Gul'): falsk
ArrayList indeholder ('Hvid'): sandt

Output - ArrayList indeholder

Som vist i ovenstående output kontrollerer metoden 'indeholder', om det angivne argument er til stede i ArrayList og returnerer sandt eller falsk.

ArrayList få

Prototype: E get (int-indeks)
Parametre: index => Index hvor elementet skal hentes fra ArrayList.
Returværdi: E => Elementværdi ved det givne indeks i ArrayList.
Beskrivelse: Returnerer elementet på listen til stede på den position, der er angivet af 'indeks'.
Undtagelser: IndexOutOfBoundsException => Hvis indekset er uden for grænserne.

ArrayList sæt (Udskift element)

Prototype: E-sæt (int-indeks, E-element)
Parametre: index => Index hvor elementet skal udskiftes.
Element => Nyt element, der skal indstilles til det angivne indeks.
Returværdi: E => Element, der erstattes af den indstillede operation.
Beskrivelse: Indstiller elementværdien ved det givne 'indeks' til den nye værdi givet af 'elementet'.
Undtagelser: IndexOutOfBoundsException => Hvis indekset er uden for grænserne

Java-programmet nedenfor bruger get () og set () -metoden til at hente og erstatte værdier i 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)); } }

Produktion:

Indtastning på indeks 2 før opkald for at indstille: Blå
Indgang til indeks 2 efter indstilling for at indstille: Gul

Produktion

ArrayList klar

Prototype: ugyldigt klart ()
Parametre: NIL
Returværdi: ugyldig
Beskrivelse: Rydder listen ved at fjerne alle elementerne fra listen.

ArrayList er tom

Prototype: boolsk isEmpty ()
Parametre: NIL
Returværdi: true => hvis listen er tom
Beskrivelse: Kontrollerer, om den givne liste er tom.

Clear () og isEmpty () -funktionerne vises nedenfor.

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

Produktion:

ArrayList: (Rød, grøn, blå, hvid)
Er ArrayList tom efter clear ()? :sand

Output - er Tom ArrayList

ArrayList indexOf

Prototype: int indexOf (Objekt o)
Parametre: o => Element, hvis indeks findes i ArrayList.
Returværdi: int => Indeks for den første forekomst af elementet på listen.
Beskrivelse: Returnerer indekset for den første forekomst af elementet o på listen. -1 hvis elementet o ikke er til stede på listen.

ArrayList lastIndexOf

Prototype: int lastIndexOf (Objekt o)
Parametre: o => Det element, der skal søges efter.
Returværdi: int => Indeks for den sidste forekomst af elementet på listen.
Beskrivelse: Returnerer indekset for den sidste forekomst af det angivne element o på listen. -1 hvis elementet ikke er til stede på listen.

Nedenstående Java-program demonstrerer indexOf- og lastIndexOf-metoderne for 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)); } }

Produktion:

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

Produktion

ArrayList toArray

Prototype: Objekt () toArray ()
Parametre: NIL
Returværdi: Objekt () => en matrix. Dette returnerede array indeholder alle elementerne på listen i en korrekt rækkefølge.
Beskrivelse: Konverterer den givne liste til en matrix.

Prototype: T () til Array (T () a)

Parametre: a => Array for at gemme elementer på listen. Hvis størrelsen på matrixen ikke er tilstrækkelig til listeelementer, oprettes en anden matrix med samme type som a til lagring af elementer.

Returværdi: T () => Matrix, der indeholder alle listeelementerne.
Beskrivelse: Konverterer den givne liste til en matrix af typen angivet med a.

Undtagelser: ArrayStoreException => Hvis der er uoverensstemmelse i runtime-typen af arrayet og runtime-typen eller supertypen på dets elementer.
NullPointerException => Det givne array er nul

Java-programmet nedenfor viser toArray-metoden til 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)); } }

Produktion:

ArrayList: (10, 20, 30, 40, 50)
Array fra ArrayList: (10, 20, 30, 40, 50)

Output - toArray ArrayList

ArrayList-klon

Prototype: Objektklon ()
Parametre: NIL
Returværdi: Objekt => Klon af ArrayList-forekomsten.
Beskrivelse: Opretter en lav kopi af den givne 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); } }

Produktion:

Original ArrayList: (Apple, Orange, Melon, Druer)
Cloned ArrayList: (Æble, appelsin, melon, druer)
Original ArrayList efter tilføj & fjern: (Æble, melon, druer, mango)
Klonet ArrayList efter ændring af original: (Apple, Orange, Melon, Druer)

output - arraylist-klon

Fra ovenstående programoutput kan du se, at den klonede ArrayList er en lav kopi af den originale ArrayList. Dette betyder, at når den originale ArrayList ændres, reflekteres disse ændringer ikke i den klonede ArrayList, da de ikke deler hukommelsesplaceringerne for hvert element.

For at lave en dyb kopi af Array skal den originale ArrayList gennemkøres, og hvert af dens elementer skal kopieres til ArrayList-destinationen.

ArrayList-underliste

Prototype: Liste underliste (int fraIndex, int tilIndex)
Parametre: fromIndex => Startindeks for intervallet (inklusive)
toIndex => Slutindeks for intervallet (eksklusiv)
Returværdi: Liste => Underliste over listen i det givne interval.

Beskrivelse: Returnerer en underliste mellem et givet interval, fra index til indeks for den givne liste. Bemærk, at denne underliste eller visningen af listen i det givne område understøtter alle de funktioner, der understøttes af listen. Ingen visning returneres, hvis fraIndex = tilIndex.

Undtagelser: IndexOutOfBoundsException => Kastes når toIndex er uden for rækkevidde.
IllegalArgumentException => Hvis fraIndex> tilIndex dvs. indekser er ude af drift.

Lad os se et eksempel på subList-metoden.

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

Produktion:

bedste gratis software til forbedring af pc-ydeevne

Original ArrayList: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
Underliste over given ArrayList: (15, 20, 25, 30)

Produktion

ArrayList beholder alt

Prototype: boolean retainAll (Collection c)
Parametre: c => Samling med elementer, der skal bevares på listen.
Returværdi: true => Hvis ArrayList ændres som et resultat af operationen.
Beskrivelse: Beholder de elementer på listen, der matcher elementerne i den givne samling c.

Undtagelser: ClassCastException => Samlingstypen og listetypen stemmer ikke overens
NullPointerException => Den givne samling er nul, eller listen indeholder null-element, og samlingen tillader ikke nul.

Det følgende program demonstrerer retainAll-metoden.

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

Produktion:

Original ArrayList: (Rød, grøn, blå, gul)
Samlingselementer, der skal opbevares på listen: (Rød, Blå)
ArrayList efter retainAlle opkald: (Rød, Blå)

Output - retailAll metode

ArrayList Iterator

Prototype: Iterator iterator ()
Parametre: NIL
Returværdi: Iterator => iterator over listeelementerne.
Beskrivelse: Returnerer en iterator til at krydse over listeelementerne i den rigtige rækkefølge.

ArrayList listIterator

JEG.

Prototype: ListIterator listIterator ()
Parametre: NIL
Returværdi: ListIterator => listIterator over listeelementerne.
Beskrivelse: Returnerer liste iterator til at krydse over elementerne i den givne liste.

II.

Prototype: ListIterator listIterator (int index)
Parametre: index => Position for det første element i listIterator.
Returværdi: ListIterator => ListIterator for listen fra specificeret indeks.
Beskrivelse: Returnerer listen iterator startende fra den angivne position 'indeks' for at krydse over elementerne i den givne liste.
Undtagelser: IndexOutOfBoundsException => Det givne indeks er uden for området.

Eksempel på iterator () og listIterator () metoder.

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

Produktion:

Liste over indhold ved hjælp af Iterator () -metoden:
Mumbai Pune Hyderabad Delhi
Listeindhold ved hjælp af listIterator () -metoden:
Mumbai Pune Hyderabad Delhi

Output - Iterator og listIterator Methods

Føj Array til ArrayList i Java

ArrayList understøtter metoden addAll til at føje elementer fra samlingen til ArrayList. På en lignende måde kan du også føje en Array til ArrayList. Dette gøres ved hjælp af 'Collections.addAll' -metoden.

Eksempel på tilføjelse af en Array til 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); } }

Produktion:

Indledende ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
ArrayList efter tilføjelse af array: (Delhi, Mumbai, Chennai, Kolkata, Cochin, Goa)

output - Føj Array til Arraylist i Java

Sorter ArrayList i Java

ArrayList bruger metoden Collections.sort til at sortere dens elementer. Som standard sorteres listen i stigende rækkefølge efter metoden Collections.sort. Hvis ArrayList skal sorteres i faldende rækkefølge, skal du give 'Collections.reverseOrder ()' en parameter til sorteringsmetoden.

Nedenfor er et program til at sortere en ArrayList i stigende og faldende rækkefølge:

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

Produktion:

Indledende matrixliste: (Rød, grøn, blå, gul)
ArrayList sorteret i stigende rækkefølge:
(Blå, grøn, rød, gul)
ArrayList sorteret i faldende rækkefølge:
(Gul, Rød, Grøn, Blå)

Output - sorter array arraylist i Java

I tilfælde af at ArrayList indeholder andre klasseobjekter som elementer, kan du gøre brug af Comparable og Comparator-grænseflader. Flere detaljer om grænseflader vil blive dækket i vores senere tutorials.

Vend en ArrayList i Java

Du kan også vende en ArrayList i Java. En metode til at gøre dette er at bruge den traditionelle metode til at krydse ArrayList i omvendt rækkefølge og kopiere hvert element til en ny ArrayList.

En anden metode er at bruge klassen Samlinger, der giver den 'omvendte' metode, der bruges til at vende en samling.

hvordan man arkiverer en fejlrapport

Programmet til at vende en ArrayList ved hjælp af klassen Collections er angivet nedenfor.

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

Produktion:

Indledende matrixliste: (1, 3, 5, 7, 9)
Omvendt ArrayList: (9, 7, 5, 3, 1)

Output - Reverse og ArrayList

Fjern duplikater fra en ArrayList i Java

For at fjerne dubletter fra ArrayList kan du igen bruge den traditionelle metode til at bruge en iterator til at krydse ArrayList og kun gemme den første forekomst af elementet i en anden ArrayList.

Endnu en anden metode er ved at bruge den 'forskellige ()' metode til stream () klasse. Denne metode returnerer en strøm af forskellige elementer. Stream () -funktionen er tilgængelig i Java fra og med Java 8.

Implementeringen af stream () .distinct () -metoden er angivet nedenfor:

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

Produktion:

Original ArrayList: (1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)
ArrayList uden dubletter: (1, 2, 3, 5, 6, 7, 8)

Output - Fjern dubletter fra ArrayList

Bland (tilfældigt) en ArrayList i Java

Du kan også 'blande' eller randomisere ArrayList-elementerne. Dette gøres ved hjælp af metoden Collections.shuffle (). Ved hjælp af denne metode kan du enten blande ArrayList med standardindstillinger eller give en tilfældig () funktion, der vil randomisere elementerne i henhold til den tilfældige værdi.

Et Java-program for at opnå dette er angivet nedenfor.

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

Produktion:

Oprindelig ArrayList: (øst, vest, nord, syd, sydvest, nordøst) Blandet ArrayList uden tilfældig (): (nord, nordøst, øst, sydvest, syd, vest)
Blandet ArrayList med tilfældig (): (syd, øst, nord, nordøst, vest, sydvest)
Blandet ArrayList med tilfældig (2): (sydvest, syd, øst, nordøst, nord, vest)

Output - Bland (randomiser) en ArrayList

Ofte stillede spørgsmål

Q # 1) Hvad er forskellen mellem homogene og heterogene containere i Java?

Svar: Homogene beholdere indeholder genstande / elementer af samme type. På den anden side har heterogene beholdere genstande af blandet type.

Q # 2) Er ArrayList i Java heterogen?

Svar: Ja. Da ArrayLists understøtter generiske stoffer og derfor sletter sletning, kan den indeholde blandede objekter, når de implementeres som en generisk ArrayList.

Q # 3) Kan ArrayList gemme int?

Svar: Nej. ArrayLists kan ikke gemme værdier som int, men det kan gemme Integer-objekter, da ArrayLists kun kan indeholde objekter. For at gemme primitive typer skal du bruge indpakningsklasser som Integer til ints.

Q # 4) Hvad sker der, når ArrayList er fuld?

Svar: Hvert ArrayList-objekt har en funktion, der hedder 'kapacitet'. Når ArrayList er fuld, øges ArrayListens kapacitet automatisk for at give plads til flere elementer.

Q # 5) Hvad er forskellen mellem metoden removeAll og retainAll i ArrayList?

Svar: ArrayList-metoderne 'removeAll' og 'retainAll' udviser modsat adfærd.

Mens metoden removeAll fjerner alle de elementer fra listen, der matcher den samling, der er sendt som et argument til denne metode, bevarer retainAll på den anden side alle de elementer på listen, der matcher den i samlingen.

Konklusion

I denne vejledning har vi diskuteret ArrayList-metoder detaljeret med et eksempel.

Vi har også overvejet nogle specielle tilfælde som at tilføje elementer på forsiden af listen. Vi diskuterede også andre operationer på ArrayList som sortering, reversering og blanding af ArrayList.

I vores kommende vejledning vil vi diskutere nogle af ArrayList-konverteringerne.

=> Pas på den enkle Java-træningsserie her.

ArrayList-metoder i Java - vejledning med eksempelprogrammer