ArrayList-metoder i Java

arraylist methods java tutorial with example programs

Prova Vårt Instrument För Att Eliminera Problem

Välj Operativsystemet Välj Ett Projektprogram (Valfritt)

Beskriv Ditt Problem

I den här självstudien kommer vi att diskutera Java ArrayList-metoder som add, addAll, remove, removeAll, storlek, innehåller, retainAll, Sort, Reverse, etc. med exempel:

I föregående handledning utforskade vi ArrayList-datastrukturen och ArrayList-klassen tillhandahöll denna datastruktur / insamling i Java. Vi har lärt oss att skapa, initiera etc. av ArrayList-objekten.

Förutom dessa funktioner som hjälper oss att definiera ArrayList, tillhandahåller ArrayList-klassen i Java också ett fullfjädrat funktions-API som består av metoder som används för att manipulera ArrayList-objekt.

=> Kontrollera ALLA Java-handledning här.

Dessa metoder gör det möjligt för oss att lägga till, radera, söka element i ArrayList samt att hämta längden / storleken på ArrayList-element, etc.

Java ArrayList_Methods

I denna handledning kommer vi att diskutera dessa metoder i detalj med enkla programmeringsexempel.

Vad du kommer att lära dig:

I följande tabell listas alla metoder som tillhandahålls av ArrayList-klassen.

Metod	Metodprototyp	Metodbeskrivning
Innehåller	boolean innehåller (Objekt o)	Kontrollerar om listan innehåller det givna elementet ”o”. Returnerar sant om elementet är närvarande.
Lägg till	boolesk tillsats (E e)	Lägger till givet element e i slutet av listan.
Lägg till	void add (int index, E element)	Lägger till givet element 'element' vid den angivna positionen 'index'.
Lägg till alla	booleska addAll (samling c)	Lägger till alla element i den givna samlingen c till slutet av listan.
Lägg till alla	boolean addAll (int index, Collection c)	Lägger till alla element i den givna samlingen c på den plats som anges av 'index' i listan.
Klar	ogiltig rensa ()	Rensar listan genom att ta bort alla element från listan.
Klona	Objektklon ()	Gör en grunt kopia av den givna ArrayList.
säkerställa kapacitet	void ensureCapacity (int minCapacity)	Ökar ArrayListens kapacitet för att säkerställa att den har minCapacity.
Skaffa sig	E get (int index)	Returnerar elementet i listan som finns på den position som anges av 'index'.
index för	int indexOf (Objekt o)	Returnerar index för den första förekomsten av element o i listan. -1 om element o inte finns i listan.
är tom	boolean isEmpty ()	Kontrollerar om listan är tom.
Iterator	Iterator iterator ()	Returnerar en iterator som passerar över listelementen i rätt ordning.
lastIndexOf	int lastIndexOf (Object o)	Returnerar index för den senaste förekomsten av det angivna elementet o i listan. -1 om elementet inte finns i listan.
listIterator	ListIterator listIterator ()	Returnerar lista iterator för att korsa över elementen i den angivna listan.
listIterator	ListIterator listIterator (int index)	Returnerar listens iterator från den angivna positionen 'index' för att korsa över elementen i den angivna listan.
ta bort	E ta bort (int index)	Raderar elementet i indexet i ArrayList.
ta bort	boolean ta bort (Objekt o)	Tar bort den första förekomsten av element o från listan.
ta bort alla	boolean removeAll (samling c)	Tar bort alla element från listan som matchar elementen i en viss samling c.
removeRange	skyddad tomrum removeRange (int frånIndex, int tillIndex)	Tar bort element som anges i det angivna intervallet, frånIndex (inklusive) tillIndex (exklusivt) från listan.
behålla allt	boolean retainAll (Collection c)	Behåller de element i listan som matchar elementen i den givna samlingen c.
uppsättning	E-uppsättning (int-index, E-element)	Ställer in elementvärdet vid angivet 'index' till det nya värdet som ges av 'element'.
storlek	int storlek ()	Returnerar det totala antalet element eller längden på listan.
underlista	Lista sublista (int fromIndex, int toIndex)	Returnerar en underlista mellan ett visst intervall, från index till index för den angivna listan.
toArray	Objekt () toArray ()	Konverterar den angivna listan till en matris.
toArray	T () toArray (T () a)	Konverterar den angivna listan till en matris av typen som ges av a.
trimToSize	ogiltig trimToSize ()	Trimmar ArrayList-kapaciteten till storleken eller antalet element som finns i listan.

Därefter kommer vi att diskutera var och en av dessa metoder från ArrayList-funktionens API i detalj och presentera programmeringsexempel. Efter att ha diskuterat alla metoderna som listas ovan tar vi också upp vissa specifika operationer som utförs med hjälp av ArrayLists som inte ingår i ArrayList-funktionens API.

ArrayList lägg till

Jag

Prototyp: boolesk tillsats (E e)
Parametrar: e => Element som ska läggas till i ArrayList.
Returvärde: true => Element har lagts till.
Beskrivning: Lägger till det givna elementet e i slutet av listan.

II.

Prototyp: void add (int index, E element)

Parametrar:

index => Position där elementet ska läggas till.
Element => Element som ska läggas till i ArrayList.

Returvärde: tomhet

Beskrivning: Lägger till givet element 'element' vid den angivna positionen 'index' genom att flytta elementet vid den positionen och efterföljande element till höger.

Undantag: IndexOutOfBoundsException => Om det angivna indexet ligger utanför intervallet.

ArrayList addAll

Jag

Prototyp: booleska addAll (samling c)
Parametrar: c => Samling vars element ska läggas till i ArrayList.
Returvärde: true => Om åtgärden har ändrat ArrayList.

Beskrivning: Lägger till alla element i den givna samlingen c till slutet av listan. Resultatet av operationen är odefinierat om insamlingen ändras när operationen pågår.

Undantag: NullPointerException => Om given samling är c noll.

Prototyp: boolean addAll (int index, Collection c)
Parametrar: index => Position där elementen i den givna samlingen ska läggas till.
Returvärde: true => Om listan har ändrats till följd av operationen.

Beskrivning: Lägger till alla element i den givna samlingen c på den plats som anges av 'index' i listan. Elementet vid det angivna indexet och efterföljande element flyttas till höger. Resultatet av operationen är odefinierat om samlingen som läggs till ändras när operationen pågår.

Undantag: IndexOutOfBoundsException: om indexet där samlingen ska läggas till är utanför gränserna
NullPointerException: om den givna samlingen c är null.

skillnad mellan testplan och testfall

Följande Java-program visar användningen av add och 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:

Initial ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
rrayList efter att ha lagt till element i index 1: (Delhi, NYC, Mumbai, Chennai, Kolkata)
ArrayList efter att ha lagt till lista i index 4: (Delhi, NYC, Mumbai, Chennai, Pune, Hyderabad, Kolkata)

Utdata från Java ArrayList addAll

Ovanstående program använder båda versionerna av add-metoden för att lägga till element i listan. Det lägger också till en samling i listan i det angivna indexet. Lägg märke till att elementen flyttas till höger om ArrayList, vilket framgår av programmets resultat.

ArrayList Lägg till fronten

Som redan nämnts lägger den första versionen av add-metoden till elementen i slutet av listan. Om du vill lägga till elementen i början av ArrayList måste du använda den andra versionen av add-metoden. Denna tilläggsmetod tar ett index som en parameter. Detta index är den position där elementet ska läggas till.

För att lägga till elementet i början av listan måste du ange indexet som 0 som är början på listan.

Följande program lägger till ett element på framsidan av 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:

Inledande ArrayList:
(5, 7, 9)
ArrayList efter att ha lagt till element i början:
(1, 3, 5, 7, 9)

Output - ArrayList lägg till fronten

ArrayList ta bort

Prototyp: E ta bort (int index)
Parametrar: index => Position där elementet ska tas bort från ArrayList.
Returvärde: E => Element som raderas
Beskrivning: Raderar elementet i indexet i ArrayList och flyttar efterföljande element åt vänster.
Undantag: IndexOutOfBoundsException => Angivet index är utanför intervallet.

II.

Prototyp: boolean ta bort (Objekt o)
Parametrar: o => Element som ska tas bort från ArrayList.
Returvärde: true => Om elementet finns i listan.

Beskrivning: Tar bort den första förekomsten av element o från listan. Om elementet inte finns i listan har den här åtgärden ingen effekt. När elementet har raderats flyttas de efterföljande elementen åt vänster.

ArrayList removeAll

Prototyp: boolean removeAll (samling c)
Parametrar: c => Samling vars element matchar dem i ArrayList och ska tas bort.
Returvärde: true => Om ArrayList ändras av operationen.

Beskrivning: Tar bort alla element från listan som matchar elementen i den givna samlingen c. Som ett resultat flyttas de återstående elementen till vänster om listan.

Undantag: ClassCastException => Klass är inte densamma som för den angivna samlingen, vilket innebär att klassen är oförenlig.
NullPointerException => Om den givna samlingen c är null; eller om c har ett nullelement och det inte är tillåtet av samlingen.

ArrayList removeRange

Prototyp: skyddad tomrum removeRange (int frånIndex, int tillIndex)
Parametrar: fromIndex => Index för startelementet i området som ska tas bort.
toIndex => Index för elementet efter det sista elementet i området som ska tas bort.
Returvärde: tomhet
Beskrivning: Tar bort element som anges i det angivna intervallet, frånIndex (inklusive) tillIndex (exklusivt) från listan. Den här åtgärden förkortar listans längd med (toIndex-fromIndex). Denna åtgärd har ingen effekt i fallet frånIndex = tillIndex.
Undantag: IndexOutOfBoundsException => Om något av indexen (frånIndex eller toIndex) är utanför gränserna.

Låt oss implementera ett Java-program för att visa några av dessa borttagningsmetoder som vi diskuterade ovan.

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:

Initial ArrayList: (Delhi, Mumbai, Chennai, Kolkata, Pune, Hyderabad
ArrayList efter att ha tagit bort element i index 2: (Delhi, Mumbai, Kolkata, Pune, Hyderabad)
ArrayList efter att ha tagit bort element -> Kolkata: (Delhi, Mumbai, Pune, Hyderabad)
ArrayList efter samtal för att ta bortAllt: (Mumbai, Pune)

Output- ArrayList removeAll range

ArrayList storlek (längd)

Prototyp: int storlek ()
Parametrar: NOLL
Returvärde: int => Antal element i ArrayList.
Beskrivning: Returnerar det totala antalet element eller längden på ArrayList.

Säkerställ kapacitet

Prototyp: void ensureCapacity (int minCapacity)
Parametrar: minCapacity => Minsta kapacitet som önskas för ArrayList.
Returvärde: tomhet
Beskrivning: Ökar ArrayListens kapacitet för att säkerställa att den har minCapacity.

trimToSize

Prototyp: ogiltig trimToSize ()
Parametrar: NOLL
Returvärde: tomhet
Beskrivning: Trimmar ArrayList-kapaciteten till storleken eller antalet element som finns i listan.

Nedanstående programmeringsexempel visar metodernas storlek (), säkerställ Kapacitet () och 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:

Initial storlek: 0
Originallista: (2, 4, 6, 8, 10)
ArrayList-storlek efter tillsats: 5
ArrayList-storlek efter ensureCapacity () anrop och lägg till operation: 7
ArrayList-storlek efter trimToSize (): 7
ArrayList final:
2 4 6 8 10 12 14

Output- ArrayList-storlek (längd)

ArrayList innehåller

Prototyp: boolean innehåller (Objekt o)
Parametrar: o => Element som ska kontrolleras om det finns i ArrayList.
Returvärde: true => Om ArrayList innehåller element o.
Beskrivning: Kontrollerar om listan innehåller det givna elementet ”o”. Returnerar sant om elementet är närvarande.

Vi använder metoden 'innehåller' i följande 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 innehåller (”Red Green”): false
ArrayList innehåller (”Blå”): sant
ArrayList innehåller ('Yellow'): false
ArrayList innehåller (”Vit”): sant

Output - ArrayList innehåller

Som visas i ovanstående utdata kontrollerar metoden 'innehåller' om argumentet som tillhandahålls finns i ArrayList och returnerar true eller false.

ArrayList få

Prototyp: E get (int index)
Parametrar: index => Index där elementet ska hämtas från ArrayList.
Returvärde: E => Elementvärde vid det angivna indexet i ArrayList.
Beskrivning: Returnerar elementet i listan som finns på den position som anges av 'index'.
Undantag: IndexOutOfBoundsException => Om indexet är utanför gränserna.

ArrayList set (Byt ut element)

Prototyp: E-uppsättning (int-index, E-element)
Parametrar: index => Index där elementet ska bytas ut.
Element => Nytt element som ska ställas in vid det angivna indexet.
Returvärde: E => Element som ersätts av uppsättningen.
Beskrivning: Ställer in elementvärdet vid det angivna ”indexet” till det nya värdet som ges av “elementet”.
Undantag: IndexOutOfBoundsException => Om indexet är utanför gränserna

Java-programmet nedan använder metoden get () och set () för att hämta och ersätta värden 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:

Anmälan till index 2 före anrop för att ställa in: Blå
Anmälan till index 2 efter inställning: Gul

Produktion

ArrayList klar

Prototyp: ogiltig rensa ()
Parametrar: NOLL
Returvärde: tomhet
Beskrivning: Rensar listan genom att ta bort alla element från listan.

ArrayList är tom

Prototyp: boolean isEmpty ()
Parametrar: NOLL
Returvärde: true => om listan är tom
Beskrivning: Kontrollerar om listan är tom.

Rensa () och isEmpty () -funktioner visas nedan.

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å, vit)
Är ArrayList tom efter clear ()? :Sann

Output - isEmpty ArrayList

programvara för att spionera på mobiltelefoner

ArrayList indexOf

Prototyp: int indexOf (Objekt o)
Parametrar: o => Element vars index finns i ArrayList.
Returvärde: int => Index för den första förekomsten av elementet i listan.
Beskrivning: Returnerar index för den första förekomsten av elementet o i listan. -1 om elementet o inte finns i listan.

ArrayList lastIndexOf

Prototyp: int lastIndexOf (Object o)
Parametrar: o => Det element som ska sökas efter.
Returvärde: int => Index för den sista förekomsten av elementet i listan.
Beskrivning: Returnerar index för den senaste förekomsten av det angivna elementet o i listan. -1 om elementet inte finns i listan.

Nedanstående Java-program visar indexOf- och lastIndexOf-metoderna för 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

Prototyp: Objekt () toArray ()
Parametrar: NOLL
Returvärde: Objekt () => en matris. Den returnerade matrisen innehåller alla element i listan i rätt ordning.
Beskrivning: Konverterar den angivna listan till en matris.

Prototyp: T () toArray (T () a)

Parametrar: a => Array för att lagra element i listan. Om storleken på matrisen inte räcker för listelement skapas en annan matris av samma typ som a för lagring av element.

Returvärde: T () => Matris som innehåller alla listelement.
Beskrivning: Konverterar den angivna listan till en matris av typen som ges av a.

Undantag: ArrayStoreException => Om det finns en felaktig matchning i runtime-typen av arrayen och runtime-typen eller supertypen för dess element.
NullPointerException => Den givna matrisen är null

Java-programmet nedan visar toArray-metoden för 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 från ArrayList: (10, 20, 30, 40, 50)

Output - toArray ArrayList

ArrayList-klon

Prototyp: Objektklon ()
Parametrar: NOLL
Returvärde: Objekt => Klon av ArrayList-instansen.
Beskrivning: Gör en grunt kopia av den givna 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, Druvor)
Cloned ArrayList: (Apple, Orange, Melon, Druvor)
Original ArrayList efter lägg till & ta bort: (Äpple, melon, vindruvor, mango)
Klonad ArrayList efter ändring av original: (Apple, Orange, Melon, Druvor)

output - arraylist klon

Från ovanstående programutgång kan du se att den klonade ArrayList är en grunt kopia av den ursprungliga ArrayList. Detta innebär att när den ursprungliga ArrayList ändras återspeglas dessa ändringar inte i den klonade ArrayList eftersom de inte delar minnesplatserna för varje element.

För att göra en djup kopia av Array måste den ursprungliga ArrayList korsas och vart och ett av dess element måste kopieras till destinationen ArrayList.

ArrayList subList

Prototyp: Lista sublista (int fromIndex, int toIndex)
Parametrar: fromIndex => Startindex för intervallet (inklusive)
toIndex => Slutindex för intervallet (exklusivt)
Returvärde: Lista => Underlista över listan inom det angivna intervallet.

Beskrivning: Returnerar en underlista mellan ett visst intervall, från index till index för den angivna listan. Observera att den här underlistan eller vyn i listan inom det angivna intervallet stöder alla funktioner som stöds av listan. Ingen vy returneras om frånIndex = tillIndex.

Undantag: IndexOutOfBoundsException => Kastas när toIndex är utanför intervallet.
IllegalArgumentException => Om frånIndex> tillIndex, dvs index är ur funktion.

Låt oss se ett exempel 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:

Original ArrayList: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
Underlista över given ArrayList: (15, 20, 25, 30)

Produktion

ArrayList behållerAll

Prototyp: boolean retainAll (Collection c)
Parametrar: c => Samling med element som ska behållas i listan.
Returvärde: true => Om ArrayList ändrades till följd av operationen.
Beskrivning: Behåller de element i listan som matchar elementen i den givna samlingen c.

Undantag: ClassCastException => Samlingstyp och listtyp matchar inte
NullPointerException => En given samling är null eller listan innehåller null-element och samlingen tillåter inte null.

Följande program visar metoden 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); } }

Produktion:

Original ArrayList: (Röd, grön, blå, gul)
Samlingselement som ska behållas i listan: (Röd, Blå)
ArrayList efter retainAllt samtal: (Röd, blå)

Output - retailAll-metoden

ArrayList Iterator

Prototyp: Iterator iterator ()
Parametrar: NOLL
Returvärde: Iterator => iterator över listelementen.
Beskrivning: Returnerar en iterator som passerar över listelementen i rätt ordning.

ArrayList listIterator

Prototyp: ListIterator listIterator ()
Parametrar: NOLL
Returvärde: ListIterator => listIterator över listelementen.
Beskrivning: Returnerar lista iterator för att korsa över elementen i den angivna listan.

II.

Prototyp: ListIterator listIterator (int index)
Parametrar: index => Position för det första elementet i listIterator.
Returvärde: ListIterator => ListIterator för listan från angivet index.
Beskrivning: Returnerar listens iterator från den angivna positionen 'index' för att korsa över elementen i den angivna listan.
Undantag: IndexOutOfBoundsException => Angivet index är utanför intervallet.

Exempel på iterator () och 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:

Lista innehåll med Iterator () -metoden:
Mumbai Pune Hyderabad Delhi
Lista innehåll med listIterator () -metoden:
Mumbai Pune Hyderabad Delhi

Output - Iterator and listIterator Methods

Lägg till Array i ArrayList i Java

ArrayList stöder metoden addAll för att lägga till element i samlingen till ArrayList. På liknande sätt kan du också lägga till en Array i ArrayList. Detta görs med metoden 'Collections.addAll'.

Exempel på att lägga till en Array i 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:

Initial ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
ArrayList efter att ha lagt till array: (Delhi, Mumbai, Chennai, Kolkata, Cochin, Goa)

output - Lägg till Array i Arraylist i Java

Sortera ArrayList i Java

ArrayList använder metoden Collections.sort för att sortera dess element. Som standard sorteras listan i stigande ordning efter metoden Collections.sort. Om ArrayList ska sorteras i fallande ordning måste du ange 'Collections.reverseOrder ()' en parameter för sorteringsmetoden.

Nedan finns ett program för att sortera en ArrayList i stigande och fallande ordning:

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:

Initial ArrayList: (Röd, grön, blå, gul)
ArrayList sorterad i stigande ordning:
(Blå, grön, röd, gul)
ArrayList sorterad i fallande ordning:
(Gul, Röd, Grön, Blå)

Output - sortera arraylista i Java

Om ArrayList innehåller andra klassobjekt som element kan du använda Comparable och Comparator-gränssnitt. Mer information om gränssnitt kommer att täckas i våra senare handledning.

Omvänd en ArrayList i Java

Du kan också vända en ArrayList i Java. En metod för att göra detta är att använda den traditionella metoden att korsa ArrayList i omvänd ordning och kopiera varje element till en ny ArrayList.

En annan metod är att använda samlingen klassen som ger 'omvänd' -metoden som används för att vända en samling.

vad är den bästa programvaran för virusborttagning

Programmet för att vända en ArrayList med hjälp av klassen Collections ges nedan.

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:

Initial ArrayList: (1, 3, 5, 7, 9)
Omvänd ArrayList: (9, 7, 5, 3, 1)

Output - Reverse och ArrayList

Ta bort dubbletter från en ArrayList i Java

För att ta bort dubbletter från ArrayList, kan du återigen använda den traditionella metoden att använda en iterator för att korsa genom ArrayList och lagra endast den första förekomsten av elementet i en annan ArrayList.

Ännu en metod är att använda metoden 'distinkt ()' för stream (). Denna metod returnerar en ström av distinkta element. Stream () -funktionen är tillgänglig i Java från och med Java 8.

Implementeringen av stream () .distinct () -metoden ges nedan:

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 utan dubbletter: (1, 2, 3, 5, 6, 7, 8)

Output - Ta bort dubbletter från ArrayList

Blanda (slumpmässigt) En ArrayList i Java

Du kan också 'blanda' eller slumpmässigt ArrayList-elementen. Detta görs med metoden Collections.shuffle (). Med den här metoden kan du antingen blanda ArrayList med standardinställningar eller tillhandahålla en slumpmässig () funktion som randomiserar elementen enligt det slumpmässiga värdet.

Ett Java-program för att uppnå detta ges nedan.

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:

Original ArrayList: (öst, väst, norr, syd, sydväst, nordost) Blandad ArrayList utan slumpmässig (): (norr, nordost, öst, sydväst, syd, väst)
Blandad ArrayList med Random (): (söder, öst, norr, nordost, väst, sydväst)
Blandad ArrayList med slumpmässig (2): (sydväst, söder, öst, nordost, norr, väst)

Output - Blanda (slumpmässigt) en ArrayList

Vanliga frågor

F # 1) Vad är skillnaden mellan homogena och heterogena behållare i Java?

Svar: Homogena behållare innehåller föremål / element av samma typ. Å andra sidan har heterogena behållare föremål av blandad typ.

F # 2) Är ArrayList i Java heterogen?

Svar: Ja. Eftersom ArrayLists stöder generics och därför skriver radering kan den innehålla blandade objekt när de implementeras som en generisk ArrayList.

F # 3) Kan ArrayList lagra int?

Svar: Nej. ArrayLists kan inte lagra värden som int men det kan lagra Integer-objekt eftersom ArrayLists endast kan innehålla objekt. För att lagra primitiva typer bör du använda omslagsklasser som Integer för ints.

F # 4) Vad händer när ArrayList är full?

Svar: Varje ArrayList-objekt har en funktion som heter ”kapacitet”. När ArrayList är full ökar ArrayListens kapacitet automatiskt för att ge plats för fler element.

F # 5) Vad är skillnaden mellan metoden removeAll och retainAll i ArrayList?

Svar: ArrayList-metoderna 'removeAll' och 'retainAll' uppvisar motsatt beteende.

Medan removeAll-metoden tar bort alla element från listan som matchar den samling som skickats som ett argument till denna metod, behåller retainAll däremot alla element i listan som matchar den i samlingen.

Slutsats

I denna handledning har vi diskuterat ArrayList-metoder i detalj med ett exempel.

Vi har också övervägt några speciella fall som att lägga till element längst fram på listan. Vi diskuterade också andra operationer på ArrayList som sortering, reversering och blandning av ArrayList.

I vår kommande handledning kommer vi att diskutera några av ArrayList-omvandlingarna.

=> Se upp den enkla Java-träningsserien här.

ArrayList-metoder i Java - handledning med exempelprogram