arraylist methods java tutorial with example programs
În acest tutorial, vom discuta despre metodele Java ArrayList, cum ar fi add, addAll, remove, removeAll, size, contains, retainAll, Sort, Reverse, etc. cu exemple:
În tutorialul anterior, am explorat structura de date ArrayList, iar clasa ArrayList a furnizat această structură / colectare de date în Java. Am învățat crearea, inițializarea etc. a obiectelor ArrayList.
În afară de aceste caracteristici care ne ajută să definim ArrayList, clasa ArrayList din Java oferă, de asemenea, o funcție API completă, care constă din metode care sunt utilizate pentru a manipula obiectele ArrayList.
=> Verificați TOATE Tutorialele Java aici.
Aceste metode ne permit să adăugăm, să ștergem, să căutăm elemente în ArrayList, precum și să preluăm lungimea / dimensiunea elementelor ArrayList etc.
În acest tutorial, vom discuta în detaliu aceste metode cu exemple simple de programare.
Ce veți învăța:
- Metode ArrayList în Java
- ArrayList add
- ArrayList addAll
- ArrayList Adăugați în față
- ArrayList elimină
- ArrayList removeAll
- ArrayList removeRange
- Dimensiunea ArrayList (Lungime)
- ArrayList conține
- ArrayList obține
- ArrayList set (Înlocuire element)
- ArrayList clar
- ArrayList este gol
- ArrayList indexOf
- ArrayList lastIndexOf
- ArrayList toArray
- Clona ArrayList
- ArrayList subList
- ArrayList retainAll
- ArrayList Iterator
- ArrayList listIterator
- Adăugați Array la ArrayList în Java
- Sortează ArrayList în Java
- Reverse o listă de matrice în Java
- Eliminați duplicatele dintr-o listă Array în Java
- Shuffle (Randomize) An ArrayList In Java
- întrebări frecvente
- Concluzie
Metode ArrayList în Java
Următorul tabel listează toate metodele furnizate de clasa ArrayList.
Metodă | Metoda prototip | Descrierea metodei |
---|---|---|
Conține | boolean conține (Obiectul o) | Verifică dacă lista conține elementul dat „o”. Returnează adevărat dacă elementul este prezent. |
Adăuga | add boolean (E e) | Adaugă elementul dat e la sfârșitul listei. |
adăugare nulă (index int, element E) | Adaugă elementul dat „element” la poziția specificată „index”. | |
Adaugă totul | boolean addAll (Colecția c) | Adaugă toate elementele din colecția dată c la sfârșitul listei. |
addAll boolean (index int, Colecția c) | Adaugă toate elementele din colecția dată c la poziția specificată de „index” din listă. | |
clar | gol clar () | Șterge lista eliminând toate elementele din listă. |
Clonează | Clonare obiect () | Face o copie superficială a ArrayList-ului dat. |
asiguraCapacitate | nul asigura capacitate (int minCapacitate) | Crește capacitatea ArrayList pentru a se asigura că are capacitatea min. |
obține | E get (int index) | Returnează elementul din lista prezentă la poziția specificată de „index”. |
Index de | int indexOf (Obiectul o) | Returnează indexul primei apariții a elementului o din listă. -1 dacă elementul o nu este prezent în listă. |
este gol | boolean isEmpty () | Verifică dacă lista dată este goală. |
Iterator | Iterator iterator () | Returnează un iterator pentru a parcurge elementele listei în ordinea corespunzătoare. |
lastIndexOf | int lastIndexOf (Obiectul o) | Returnează indexul ultimei apariții a elementului specificat o din listă. -1 dacă elementul nu este prezent în listă. |
listIterator | ListIterator listIterator () | Returnează iteratorul listei pentru a parcurge elementele listei date. |
ListIterator listIterator (index int) | Returnează iteratorul listei începând de la poziția specificată „index” pentru a parcurge elementele listei date. | |
elimina | Șterge E (index int) | Șterge elementul din „index” din ArrayList. |
eliminare booleană (Obiectul o) | Șterge prima apariție a elementului o din listă. | |
inlătură tot | boolean removeAll (Colecția c) | Elimină toate elementele din listă care se potrivesc cu elementele din colecția dată c. |
removeRange | nul protejat removeRange (int fromIndex, int toIndex) | Elimină elementele specificate în intervalul dat, de laIndex (inclusiv) la toIndex (exclusiv) din listă. |
keepAll | boolean retainAll (Colecția c) | Păstrează acele elemente din listă care se potrivesc cu elementele din colecția dată c. |
a stabilit | Set E (index int, element E) | Setează valoarea elementului la „index” dat la noua valoare dată de „element”. |
mărimea | int size () | Returnează numărul total de elemente sau lungimea listei. |
subListă | Listă subListă (int fromIndex, int toIndex) | Returnează o listă secundară între intervalul dat, de laIndex la toIndex pentru lista dată. |
toArray | Obiect () toArray () | Convertește lista dată într-o matrice. |
T () toArray (T () a) | Convertește lista dată într-o matrice de tipul dat de un. | |
trimToSize | void trimToSize () | Reduce capacitatea ArrayList la dimensiunea sau numărul de elemente prezente în listă. |
În continuare, vom discuta în detaliu fiecare dintre aceste metode din funcția ArrayList API și vom prezenta exemple de programare. După discutarea tuturor metodelor enumerate mai sus, vom lua, de asemenea, câteva operații specifice care sunt efectuate folosind ArrayLists care nu fac parte din funcția ArrayList API.
ArrayList add
Eu
Prototip: add boolean (E e)
Parametri: e => Element care trebuie adăugat la ArrayList.
Valoare returnată: adevărat => Element adăugat cu succes.
Descriere: Adaugă elementul dat e la sfârșitul listei.
II.
Prototip: adăugare nulă (index int, element E)
Parametri:
index => Poziția în care urmează să fie adăugat elementul.
Element => Element care trebuie adăugat la ArrayList.
Valoare returnată: nul
Descriere: Adaugă elementul „element” dat la poziția specificată „index” prin deplasarea elementului în poziția respectivă și a elementelor ulterioare spre dreapta.
Excepții: IndexOutOfBoundsException => Dacă indexul specificat este în afara intervalului.
ArrayList addAll
Eu
Prototip: boolean addAll (Colecția c)
Parametri: c => Colecție ale cărei elemente trebuie adăugate la ArrayList.
Valoare returnată: true => Dacă operațiunea a modificat ArrayList.
Descriere: Adaugă toate elementele din colecția dată c la sfârșitul listei. Rezultatul operației este nedefinit dacă colecția este modificată atunci când operațiunea este în desfășurare.
Excepții: NullPointerException => Dacă colecția dată c este nulă.
II
Prototip: addAll boolean (index int, Colecția c)
Parametri: index => Poziția în care trebuie adăugate elementele din colecția dată.
Valoare returnată: true => Dacă lista s-a schimbat ca urmare a operației.
Descriere: Adaugă toate elementele din colecția dată c la poziția specificată de „index” din listă. Elementul de la indexul specificat și elementele ulterioare sunt deplasate spre dreapta. Rezultatul operației este nedefinit dacă colecția adăugată este modificată atunci când operațiunea este în desfășurare.
Excepții: IndexOutOfBoundsException: dacă indexul în care urmează să fie adăugată colecția este în afara limitelor
NullPointerException: dacă colecția dată c este nulă.
Următorul program Java demonstrează utilizarea metodelor add și 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); } }
Ieșire:
ArrayList inițială: (Delhi, Mumbai, Chennai, Kolkata)
rrayList după adăugarea elementului la indexul 1: (Delhi, NYC, Mumbai, Chennai, Kolkata)
ArrayList după adăugarea listei la indexul 4: (Delhi, New York, Mumbai, Chennai, Pune, Hyderabad, Kolkata)
Programul de mai sus folosește ambele versiuni ale metodei add pentru a adăuga elemente la listă. De asemenea, adaugă o colecție la listă la indexul specificat. Rețineți deplasarea elementelor la dreapta ArrayList, așa cum reiese din rezultatul programului.
ArrayList Adăugați în față
După cum sa menționat deja, prima versiune a metodei add adaugă elementele la sfârșitul listei. Dacă doriți să adăugați elementele la începutul ArrayList, atunci trebuie să utilizați a doua versiune a metodei add. Această metodă de adăugare ia un indice ca parametru. Acest indice este poziția în care trebuie adăugat elementul.
Astfel, pentru a adăuga elementul la începutul listei, trebuie să specificați indexul ca 0, care este începutul listei.
Următorul program adaugă un element în partea din față a 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); } }
Ieșire:
Lista matricii inițiale:
(5, 7, 9)
ArrayList după adăugarea de elemente la început:
(1, 3, 5, 7, 9)
ArrayList elimină
I.
Prototip: Șterge E (index int)
Parametri: index => Poziția în care trebuie eliminat elementul din ArrayList.
Valoare returnată: E => Element care este șters
Descriere: Șterge elementul din „index” din ArrayList și mută elementele ulterioare spre stânga.
Excepții: IndexOutOfBoundsException => Indexul specificat este în afara intervalului.
II.
Prototip: eliminare booleană (Obiectul o)
Parametri: o => Element care urmează să fie eliminat din ArrayList.
Valoare returnată: true => Dacă elementul este prezent în listă.
Descriere: Șterge prima apariție a elementului o din listă. Dacă elementul nu este prezent în listă, atunci nu există niciun efect al acestei operații. Odată ce elementul este șters, elementele ulterioare sunt deplasate spre stânga.
ArrayList removeAll
Prototip: boolean removeAll (Colecția c)
Parametri: c => Colecție ale cărei elemente se potrivesc cu cele din ArrayList și urmează să fie eliminate.
Valoare returnată: true => Dacă ArrayList este modificat de operație.
Descriere: Elimină toate elementele din listă care se potrivesc cu elementele din colecția dată c. Ca rezultat, elementele rămase sunt deplasate la stânga listei.
Excepții: ClassCastException => Clasa nu este aceeași cu cea a colecției specificate, ceea ce înseamnă că clasa este incompatibilă.
NullPointerException => Dacă colecția dată c este nulă; sau dacă c are un element nul și nu este permis de colecție.
ArrayList removeRange
Prototip: nul protejat removeRange (int fromIndex, int toIndex)
Parametri: fromIndex => Indexul elementului de pornire al gamei de eliminat.
toIndex => Indexul elementului după ultimul element din intervalul de eliminat.
Valoare returnată: nul
Descriere: Elimină elementele specificate în intervalul dat, de laIndex (inclusiv) la toIndex (exclusiv) din listă. Această operație scurtează lungimea listei cu (toIndex-fromIndex). Această operațiune nu are efect în cazul în care fromIndex = toIndex.
Excepții: IndexOutOfBoundsException => Dacă oricare dintre indici (fromIndex sau toIndex) este în afara limitelor.
Să implementăm un program Java pentru a demonstra unele dintre aceste metode de eliminare pe care le-am discutat mai sus.
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); } }
Ieșire:
ArrayList inițială: (Delhi, Mumbai, Chennai, Kolkata, Pune, Hyderabad
ArrayList după eliminarea elementului de la indexul 2: (Delhi, Mumbai, Kolkata, Pune, Hyderabad)
ArrayList după eliminarea elementului -> Kolkata: (Delhi, Mumbai, Pune, Hyderabad)
ArrayList după apel pentru a elimina toate: (Mumbai, Pune)
cum se deschid fișiere .7z pe Mac
Dimensiunea ArrayList (Lungime)
Prototip: int size ()
Parametri: ZERO
Valoare returnată: int => Numărul de elemente din ArrayList.
Descriere: Returnează numărul total de elemente sau lungimea ArrayList.
Asigurați capacitatea
Prototip: nul asigura capacitate (int minCapacitate)
Parametri: minCapacity => Capacitatea minimă dorită pentru ArrayList.
Valoare returnată: nul
Descriere: Mărește capacitatea ArrayList pentru a se asigura că are capacitatea min.
trimToSize
Prototip: void trimToSize ()
Parametri: ZERO
Valoare returnată: nul
Descriere: Reduce capacitatea ArrayList la dimensiunea sau numărul de elemente prezente în listă.
Exemplul de programare de mai jos demonstrează metodele size (), assureCapacity () și 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 + ' '); } } }
Ieșire:
Dimensiunea inițială: 0
Lista originală: (2, 4, 6, 8, 10)
Dimensiunea ArrayList după operația de adăugare: 5
Dimensiunea ArrayList după operația de asigurareCapacity () și adăugare: 7
ArrayList Size după operația TrimToSize (): 7
ArrayList final:
2 4 6 8 10 12 14
ArrayList conține
Prototip: boolean conține (Obiectul o)
Parametri: o => Element care trebuie verificat dacă este prezent în ArrayList.
Valoare returnată: true => Dacă ArrayList conține elementul o.
Descriere: Verifică dacă lista conține elementul dat „o”. Returnează adevărat dacă elementul este prezent.
Folosim metoda „conține” în următorul 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')); } }
Ieșire:
ArrayList conține („Verde roșu”): fals
ArrayList conține („Albastru”): adevărat
ArrayList conține („Galben”): fals
ArrayList conține („Alb”): adevărat
După cum se arată în rezultatul de mai sus, metoda „conține” verifică dacă argumentul furnizat este prezent în ArrayList și returnează adevărat sau fals.
ArrayList obține
Prototip: E get (int index)
Parametri: index => Index la care elementul trebuie preluat din ArrayList.
Valoare returnată: E => Valoarea elementului la indexul dat în ArrayList.
Descriere: Returnează elementul din lista prezentă la poziția specificată de „index”.
Excepții: IndexOutOfBoundsException => Dacă indexul este în afara limitelor.
ArrayList set (Înlocuire element)
Prototip: Set E (index int, element E)
Parametri: index => Index la care elementul urmează să fie înlocuit.
Element => Element nou care trebuie setat la indexul specificat.
Valoare returnată: E => Element care este înlocuit de operația setată.
Descriere: Setează valoarea elementului la „indexul” dat la noua valoare dată de „element”.
Excepții: IndexOutOfBoundsException => Dacă indexul este în afara limitelor
Programul Java de mai jos folosește metoda get () și set () pentru a prelua și înlocui valorile din 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)); } }
Ieșire:
Intrare la indexul 2 înainte de apel pentru a seta: Albastru
Intrare la indexul 2 după apel pentru a seta: Galben
ArrayList clar
Prototip: gol clar ()
Parametri: ZERO
Valoare returnată: nul
Descriere: Șterge lista eliminând toate elementele din listă.
ArrayList este gol
Prototip: boolean isEmpty ()
Parametri: ZERO
Valoare returnată: true => dacă lista este goală
Descriere: Verifică dacă lista dată este goală.
Funcțiile Clear () și isEmpty () sunt prezentate mai jos.
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()); } }
Ieșire:
Lista Array: (Roșu, Verde, Albastru, Alb)
ArrayList este gol după clear ()? :Adevărat
ArrayList indexOf
Prototip: int indexOf (Obiectul o)
Parametri: o => Element al cărui index se găsește în ArrayList.
Valoare returnată: int => Indexul primei apariții a elementului din listă.
Descriere: Returnează indexul primei apariții a elementului o din listă. -1 dacă elementul o nu este prezent în listă.
ArrayList lastIndexOf
Prototip: int lastIndexOf (Obiectul o)
Parametri: o => Elementul care trebuie căutat.
Valoare returnată: int => Indexul ultimei apariții a elementului din listă.
Descriere: Returnează indexul ultimei apariții a elementului specificat o din listă. -1 dacă elementul nu este prezent în listă.
Programul Java de mai jos demonstrează metodele indexOf și lastIndexOf din 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)); } }
Ieșire:
Lista Array: (1, 1, 2, 3, 5, 3, 2, 1, 1)
indexOf (1): 0
lastIndexOf (1): 8
indexOf (2): 2
lastIndexOf (2): 6
indexOf (3): 3
lastIndexOf (3): 5
indexOf (5): 4
lastIndexOf (5): 4
ArrayList toArray
Prototip: Obiect () toArray ()
Parametri: ZERO
Valoare returnată: Obiect () => o matrice. Această matrice returnată conține toate elementele listei într-o succesiune adecvată.
Descriere: Convertește lista dată într-o matrice.
Prototip: T () toArray (T () a)
Parametri: a => Matrice pentru a stoca elemente ale listei. Dacă dimensiunea matricei nu este suficientă pentru elementele listei, se creează o altă matrice cu același tip ca a pentru stocarea elementelor.
Valoare returnată: T () => Matrice care conține toate elementele listei.
Descriere: Convertește lista dată într-o matrice de tipul dat de un.
Excepții: ArrayStoreException => Dacă există o nepotrivire în tipul de execuție al matricei și tipul de execuție sau tipul supertip al elementelor sale.
NullPointerException => Matricea dată este nulă
Programul Java de mai jos demonstrează metoda toArray din 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)); } }
Ieșire:
ArrayList: (10, 20, 30, 40, 50)
Matrice din ArrayList: (10, 20, 30, 40, 50)
Clona ArrayList
Prototip: Clonare obiect ()
Parametri: ZERO
Valoare returnată: Obiect => Clonarea instanței ArrayList.
Descriere: Face o copie superficială a ArrayList-ului dat.
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); } }
Ieșire:
Original ArrayList: (măr, portocală, pepene galben, struguri)
Cloned ArrayList: (măr, portocală, pepene galben, struguri)
ArrayList original după adăugare și eliminare: (Apple, pepene galben, struguri, mango)
Clonat ArrayList după schimbarea originalului: (Măr, portocaliu, pepene galben, struguri)
Din ieșirea programului de mai sus, puteți vedea că ArrayList clonat este o copie superficială a ArrayList-ului original. Aceasta înseamnă că, atunci când ArrayList-ul original este modificat, aceste modificări nu se reflectă în ArrayList clonat, deoarece nu împărtășesc locațiile de memorie ale fiecărui element.
Pentru a face o copie profundă a Array, ArrayList-ul original trebuie parcurs și fiecare dintre elementele sale trebuie copiat în ArrayList-ul de destinație.
ArrayList subList
Prototip: Listă subListă (int fromIndex, int toIndex)
Parametri: fromIndex => Indexul inițial al intervalului (inclusiv)
toIndex => End end of the range (exclusive)
Valoare returnată: List => Sublist al listei din intervalul dat.
Descriere: Returnează o listă secundară între un anumit interval, de la index la index pentru lista dată. Rețineți că această sublistă sau vizualizarea listei din intervalul dat acceptă toate operațiunile acceptate de listă. Nu se returnează nicio vizualizare dacă fromIndex = toIndex.
Excepții: IndexOutOfBoundsException => Aruncat când toIndex este în afara intervalului.
IllegalArgumentException => Dacă fromIndex> toIndex, adică indicii sunt în neregulă.
cel mai bun DVD Ripper pentru Windows 7
Să vedem un exemplu al metodei 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); } }
Ieșire:
Original ArrayList: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
Sublistul listei Array date: (15, 20, 25, 30)
ArrayList retainAll
Prototip: boolean retainAll (Colecția c)
Parametri: c => Colecție cu elemente care urmează să fie păstrate în listă.
Valoare returnată: true => Dacă ArrayList s-a modificat ca urmare a operației.
Descriere: Păstrează acele elemente din listă care se potrivesc cu elementele din colecția dată c.
Excepții: ClassCastException => Tipul colecției și tipul listei nu se potrivesc
NullPointerException => Colecția dată este nulă sau lista conține element nul, iar colecția nu permite valori nule.
Următorul program demonstrează metoda 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); } }
Ieșire:
Original ArrayList: (Roșu, Verde, Albastru, Galben)
Elemente de colecție care trebuie păstrate în listă: (Roșu, Albastru)
ArrayList după retențieToate apelurile: (Roșu, Albastru)
ArrayList Iterator
Prototip: Iterator iterator ()
Parametri: ZERO
Valoare returnată: Iterator => iterator peste elementele listei.
Descriere: Returnează un iterator pentru a parcurge elementele listei în ordinea corespunzătoare.
ArrayList listIterator
I.
Prototip: ListIterator listIterator ()
Parametri: ZERO
Valoare returnată: ListIterator => listIterator peste elementele listei.
Descriere: Returnează iteratorul listei pentru a parcurge elementele listei date.
II.
Prototip: ListIterator listIterator (index int)
Parametri: index => Poziția primului element din listIterator.
Valoare returnată: ListIterator => ListIterator pentru lista din indexul specificat.
Descriere: Returnează iteratorul listei începând de la poziția specificată „index” pentru a parcurge elementele listei date.
Excepții: IndexOutOfBoundsException => Indicele dat este în afara intervalului.
Exemplu de metode iterator () și 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() + ' '); } } }
Ieșire:
Listează conținutul folosind metoda Iterator ():
Mumbai Pune Hyderabad Delhi
Conține lista utilizând metoda listIterator ():
Mumbai Pune Hyderabad Delhi
Adăugați Array la ArrayList în Java
ArrayList acceptă metoda addAll pentru a adăuga elemente ale colecției la ArrayList. În mod similar, puteți adăuga, de asemenea, un Array la ArrayList. Acest lucru se face folosind metoda „Collections.addAll”.
Exemplu de adăugare a unui Array la 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); } }
Ieșire:
ArrayList inițială: (Delhi, Mumbai, Chennai, Kolkata)
ArrayList după adăugarea matricei: (Delhi, Mumbai, Chennai, Kolkata, Cochin, Goa)
Sortează ArrayList în Java
ArrayList folosește metoda Collections.sort pentru a sorta elementele sale. În mod implicit, lista este sortată în ordine crescătoare prin metoda Collections.sort. Dacă ArrayList urmează să fie sortat în ordine descrescătoare, atunci trebuie să furnizați „Collections.reverseOrder ()” un parametru metodei de sortare.
Mai jos este prezentat un program pentru sortarea unei ArrayList în ordine crescătoare și descendentă:
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); } }
Ieșire:
ArrayList inițială: (roșu, verde, albastru, galben)
ArrayList sortate în ordine crescătoare:
(Albastru, verde, roșu, galben)
ArrayList sortate în ordine descrescătoare:
(Galben, Roșu, Verde, Albastru)
În cazul în care ArrayList conține alte obiecte de clasă ca elemente, atunci puteți utiliza interfețele Comparable și Comparator. Mai multe detalii despre interfețe vor fi acoperite în tutorialele noastre ulterioare.
Reverse o listă de matrice în Java
De asemenea, puteți inversa o ArrayList în Java. O metodă pentru a face acest lucru este să folosiți metoda tradițională de parcurgere a ArrayList în ordine inversă și să copiați fiecare element într-o nouă ArrayList.
O altă metodă este utilizarea clasei Colecții care oferă metoda „inversă” care este utilizată pentru a inversa o colecție.
ce este testarea alfa în testarea software
Programul pentru inversarea unei ArrayList utilizând clasa Colecții este dat mai jos.
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); } }
Ieșire:
ArrayList inițial: (1, 3, 5, 7, 9)
ArrayList inversat: (9, 7, 5, 3, 1)
Eliminați duplicatele dintr-o listă Array în Java
Pentru a elimina duplicatele din ArrayList, puteți recurge din nou la metoda tradițională de utilizare a unui iterator pentru a parcurge ArrayList și a stoca doar prima apariție a elementului într-o altă ArrayList.
O altă metodă este folosirea metodei „distinct ()” a clasei stream (). Această metodă returnează un flux de elemente distincte. Funcția stream () este disponibilă în Java începând cu Java 8.
Implementarea metodei stream () .distinct () este dată mai jos:
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); } }
Ieșire:
Original ArrayList: (1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)
ArrayList fără duplicate: (1, 2, 3, 5, 6, 7, 8)
Shuffle (Randomize) An ArrayList In Java
De asemenea, puteți „amesteca” sau randomiza elementele ArrayList. Acest lucru se face folosind metoda Collections.shuffle (). Folosind această metodă, fie puteți amesteca ArrayList cu setările implicite, fie puteți furniza o funcție random () care va randomiza elementele în funcție de valoarea aleatorie furnizată.
Un program Java pentru a realiza acest lucru este dat mai jos.
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); } }
Ieșire:
Original ArrayList: (est, vest, nord, sud, sud-vest, nord-est) ArrayList amestecat fără aleatoriu (): (nord, nord-est, est, sud-vest, sud, vest)
ArrayList amestecat cu Random (): (sud, est, nord, nord-est, vest, sud-vest)
ArrayList amestecat cu Random (2): (sud-vest, sud, est, nord-est, nord, vest)
întrebări frecvente
Q # 1) Care este diferența dintre containerele omogene și heterogene din Java?
Răspuns: Recipientele omogene conțin obiecte / elemente de același tip. Pe de altă parte, containerele eterogene au obiecte de tip mixt.
Q # 2) ArrayList în Java este eterogen?
Răspuns: Da. Deoarece ArrayLists acceptă generice și, prin urmare, ștergeți tipul, acesta poate conține obiecte mixte atunci când este implementat ca un ArrayList generic.
Q # 3) Poate ArrayList să stocheze int?
Răspuns: Nu. ArrayLists nu poate stoca valori precum int, dar poate stoca obiecte întregi, deoarece ArrayLists poate conține numai obiecte. Astfel, pentru a stoca tipuri primitive ar trebui să utilizați clase de împachetare precum Integer pentru ints.
Q # 4) Ce se întâmplă când ArrayList este plin?
Răspuns: Fiecare obiect ArrayList are o caracteristică numită „capacitate”. Când ArrayList este plin, capacitatea ArrayList crește automat pentru a face loc pentru mai multe elemente.
Q # 5) Care este diferența dintre metoda removeAll și retainAll din ArrayList?
Răspuns: Metodele ArrayList „removeAll” și „retainAll” prezintă un comportament opus.
În timp ce metoda removeAll elimină toate elementele din listă care se potrivesc cu colecția transmisă ca argument la această metodă, retainAll, pe de altă parte, păstrează toate elementele din listă care se potrivesc cu cea a colecției.
Concluzie
În acest tutorial, am discutat în detaliu metodele ArrayList cu un exemplu.
De asemenea, am luat în considerare unele cazuri speciale, cum ar fi adăugarea de elemente în partea din față a listei. Am discutat, de asemenea, alte operații pe ArrayList, cum ar fi sortarea, inversarea și amestecarea ArrayList.
În viitorul nostru tutorial, vom discuta despre unele dintre conversiile ArrayList.
=> Urmăriți aici seria de antrenament Java simplă.
Lectură recomandată
- Tutorial de reflecție Java cu exemple
- Tutorial Java String | Metode Java String cu exemple
- Metode de listă Java - Sortare listă, conține, adăugare listă, eliminare listă
- Java ArrayList - Cum să declarați, inițializați și tipăriți o listă Array
- Conversii Java ArrayList la alte colecții
- Tutorial Java SWING: Container, componente și gestionarea evenimentelor
- Inversați o matrice în Java - 3 metode cu exemple
- Tutorial JAVA pentru începători: peste 100 de tutoriale video Java practice