arraylist methods java tutorial with example programs
muzyka mp3 do pobrania bezpłatna najlepsza aplikacja
W tym samouczku omówimy metody Java ArrayList, takie jak add, addAll, remove, removeAll, size, contains, retainAll, Sort, Reverse itd. Z przykładami:
W poprzednim samouczku omówiliśmy strukturę danych ArrayList i klasę ArrayList przewidzianą dla tej struktury / kolekcji danych w Javie. Nauczyliśmy się tworzenia, inicjalizacji itp. Obiektów ArrayList.
Oprócz tych funkcji, które pomagają nam zdefiniować ArrayList, klasa ArrayList w Javie zapewnia także pełnoprawne funkcje API, które składają się z metod używanych do manipulowania obiektami ArrayList.
=> Sprawdź WSZYSTKIE samouczki Java tutaj.
Metody te pozwalają nam dodawać, usuwać, wyszukiwać elementy w ArrayList, a także pobierać długość / rozmiar elementów ArrayList itp.
W tym samouczku szczegółowo omówimy te metody z prostymi przykładami programowania.
Czego się nauczysz:
- Metody ArrayList w Javie
- ArrayList dodaj
- ArrayList addAll
- ArrayList Dodaj na wierzch
- ArrayList usuń
- ArrayList removeAll
- ArrayList removeRange
- ArrayList rozmiar (długość)
- ArrayList zawiera
- ArrayList get
- Zestaw ArrayList (Zastąp element)
- ArrayList wyczyść
- ArrayList isEmpty
- ArrayList indexOf
- ArrayList lastIndexOf
- ArrayList toArray
- Klon ArrayList
- ArrayList subList
- ArrayList retainAll
- ArrayList Iterator
- ArrayList listIterator
- Dodaj tablicę do ArrayList w Javie
- Sortuj ArrayList w Javie
- Odwróć ArrayList w Javie
- Usuń duplikaty z ArrayList w Javie
- Shuffle (Randomize) An ArrayList w Javie
- Często Zadawane Pytania
- Wniosek
Metody ArrayList w Javie
W poniższej tabeli wymieniono wszystkie metody, które są udostępniane przez klasę ArrayList.
metoda | Prototyp metody | Opis metody |
---|---|---|
Zawiera | boolean zawiera (obiekt o) | Sprawdza, czy lista zawiera dany element „o”. Zwraca wartość true, jeśli element jest obecny. |
Dodaj | add boolean (E e) | Dodaje podany element e na koniec listy. |
void add (int index, E element) | Dodaje dany element „element” na określonej pozycji „indeks”. | |
Dodać wszystko | boolean addAll (kolekcja c) | Dodaje wszystkie elementy w danej kolekcji c na koniec listy. |
boolean addAll (indeks int, kolekcja c) | Dodaje wszystkie elementy w danej kolekcji c na pozycji określonej przez „indeks” na liście. | |
Jasny | void clear () | Czyści listę, usuwając wszystkie elementy z listy. |
Klonuj | Klon obiektu () | Tworzy płytką kopię danej ArrayList. |
Zapewnij pojemność | void zapewniaCapacity (int minCapacity) | Zwiększa pojemność ArrayList, aby zapewnić minCapacity. |
Otrzymać | E get (indeks int) | Zwraca element listy obecny na pozycji określonej przez „indeks”. |
indeks | int indexOf (Object o) | Zwraca indeks pierwszego wystąpienia elementu o na liście. -1 jeśli element o nie występuje na liście. |
jest pusty | boolean isEmpty () | Sprawdza, czy podana lista jest pusta. |
Iterator | Iterator iterator () | Zwraca iterator, aby przejść przez elementy listy w odpowiedniej kolejności. |
lastIndexOf | int lastIndexOf (obiekt o) | Zwraca indeks ostatniego wystąpienia określonego elementu o na liście. -1, jeśli elementu nie ma na liście. |
listIterator | ListIterator listIterator () | Zwraca iterator listy, aby przejść przez elementy podanej listy. |
ListIterator listIterator (indeks int) | Zwraca iterator listy, zaczynając od określonej pozycji „indeks”, aby przejść przez elementy podanej listy. | |
usunąć | E usuń (indeks int) | Usuwa element w „indeksie” w ArrayList. |
boolean remove (Object o) | Usuwa pierwsze wystąpienie elementu o z listy. | |
Usuń wszystko | boolean removeAll (kolekcja c) | Usuwa wszystkie elementy z listy, które pasują do elementów w danej kolekcji c. |
removeRange | protected void removeRange (int fromIndex, int toIndex) | Usuwa elementy określone w podanym zakresie od fromIndex (włącznie) do toIndex (wyłącznie) z listy. |
retainAll | boolean retainAll (kolekcja c) | Zachowuje te elementy na liście, które pasują do elementów w danej kolekcji c. |
zestaw | Zbiór E (indeks int, element E) | Ustawia wartość elementu przy danym „indeksie” na nową wartość podaną przez „element”. |
rozmiar | rozmiar int () | Zwraca całkowitą liczbę elementów lub długość listy. |
subList | List subList (int fromIndex, int toIndex) | Zwraca subListę z podanego zakresu, od fromIndex do toIndex dla podanej listy. |
toArray | Obiekt [] toArray () | Konwertuje podaną listę na tablicę. |
T [] toArray (T [] a) | Konwertuje daną listę na tablicę typu podanego przez. | |
trimToSize | void trimToSize () | Przycina pojemność ArrayList do rozmiaru lub liczby elementów znajdujących się na liście. |
Następnie omówimy szczegółowo każdą z tych metod z interfejsu API funkcji ArrayList i przedstawimy przykłady programowania. Po omówieniu wszystkich wymienionych powyżej metod, zajmiemy się również określonymi operacjami, które są wykonywane przy użyciu ArrayLists, które nie są częścią funkcji ArrayList API.
ArrayList dodaj
ja
Prototyp: add boolean (E e)
Parametry: e => Element do dodania do ArrayList.
Wartość zwracana: true => Element został pomyślnie dodany.
Opis: Dodaje podany element e na koniec listy.
II.
Prototyp: void add (int index, E element)
Parametry:
index => Pozycja, w której element ma zostać dodany.
Element => Element do dodania do ArrayList.
Wartość zwracana: unieważnić
Opis: Dodaje dany element „element” w określonej pozycji „index”, przesuwając element w tym miejscu i kolejne elementy w prawo.
Wyjątki: IndexOutOfBoundsException => Jeśli określony indeks jest poza zakresem.
ArrayList addAll
ja
Prototyp: boolean addAll (kolekcja c)
Parametry: c => Kolekcja, której elementy mają zostać dodane do ArrayList.
Wartość zwracana: true => Jeśli operacja zmieniła ArrayList.
Opis: Dodaje wszystkie elementy w danej kolekcji c na koniec listy. Wynik operacji jest niezdefiniowany, jeśli kolekcja zostanie zmieniona, gdy operacja jest w toku.
Wyjątki: NullPointerException => Jeśli dana kolekcja c ma wartość null.
yl
Prototyp: boolean addAll (indeks int, kolekcja c)
Parametry: index => Pozycja, w której mają zostać dodane elementy w danej kolekcji.
Wartość zwracana: true => Jeśli lista uległa zmianie w wyniku operacji.
Opis: Dodaje wszystkie elementy w danej kolekcji c na pozycji określonej przez „indeks” na liście. Element o określonym indeksie i kolejne elementy są przesuwane w prawo. Wynik operacji jest niezdefiniowany, jeśli dodawana kolekcja zostanie zmieniona, gdy operacja jest w toku.
Wyjątki: IndexOutOfBoundsException: jeśli indeks, do którego ma zostać dodana kolekcja, jest poza zakresem
NullPointerException: jeśli dana kolekcja c ma wartość null.
Poniższy program w języku Java demonstruje użycie metod 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); } }
Wynik:
Initial ArrayList: [Delhi, Bombaj, Chennai, Kalkuta]
rrayList po dodaniu elementu w indeksie 1: [Delhi, Nowy Jork, Bombaj, Ćennaj, Kalkuta]
ArrayList po dodaniu listy w indeksie 4: [Delhi, NYC, Bombaj, Chennai, Pune, Hyderabad, Kalkuta]
Powyższy program wykorzystuje obie wersje metody add do dodawania elementów do listy. Dodaje również kolekcję do listy pod określonym indeksem. Zwróć uwagę na przesunięcie elementów na prawo od ArrayList, co widać na podstawie danych wyjściowych programu.
ArrayList Dodaj na wierzch
Jak już wspomniano, pierwsza wersja metody add dodaje elementy na koniec listy. Jeśli chcesz dodać elementy na początku ArrayList, musisz skorzystać z drugiej wersji metody add. Ta metoda add przyjmuje indeks jako parametr. Ten indeks to pozycja, w której ma zostać dodany element.
Dlatego aby dodać element na początku listy, musisz określić indeks jako 0, który jest początkiem listy.
Poniższy program dodaje element na początku 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); } }
Wynik:
Initial ArrayList:
[5, 7, 9]
ArrayList po dodaniu elementów na początku:
[1, 3, 5, 7, 9]
ArrayList usuń
JA.
Prototyp: E usuń (indeks int)
Parametry: index => Pozycja, w której element ma zostać usunięty z ArrayList.
Wartość zwracana: E => Element, który jest usuwany
Opis: Usuwa element w „indeksie” w ArrayList i przesuwa kolejne elementy w lewo.
Wyjątki: IndexOutOfBoundsException => Określony indeks jest poza zakresem.
II.
Prototyp: boolean remove (Object o)
Parametry: o => Element, który ma zostać usunięty z ArrayList.
Wartość zwracana: true => Jeśli element znajduje się na liście.
Opis: Usuwa pierwsze wystąpienie elementu o z listy. Jeśli elementu nie ma na liście, to nie ma żadnego efektu tej operacji. Po usunięciu elementu kolejne elementy są przesuwane w lewo.
ArrayList removeAll
Prototyp: boolean removeAll (kolekcja c)
Parametry: c => Kolekcja, której elementy pasują do elementów ArrayList i mają zostać usunięte.
Wartość zwracana: true => Jeśli ArrayList zostanie zmieniona przez operację.
Opis: Usuwa wszystkie elementy z listy, które pasują do elementów w danej kolekcji c. W rezultacie pozostałe elementy są przesuwane na lewo od listy.
Wyjątki: ClassCastException => Klasa różni się od klasy określonej kolekcji, co oznacza, że klasa jest niekompatybilna.
NullPointerException => Jeśli dana kolekcja c ma wartość null; lub jeśli c ma pusty element i nie jest to dozwolone przez kolekcję.
ArrayList removeRange
Prototyp: protected void removeRange (int fromIndex, int toIndex)
Parametry: fromIndex => Indeks elementu początkowego zakresu do usunięcia.
toIndex => Indeks elementu po ostatnim elemencie zakresu do usunięcia.
Wartość zwracana: unieważnić
Opis: Usuwa elementy określone w podanym zakresie od fromIndex (włącznie) do toIndex (wyłącznie) z listy. Ta operacja skraca długość listy o (toIndex-fromIndex). Ta operacja nie ma żadnego skutku w przypadku fromIndex = toIndex.
Wyjątki: IndexOutOfBoundsException => Jeśli którykolwiek z indeksów (fromIndex lub toIndex) jest poza zakresem.
Zaimplementujmy program Java, aby zademonstrować niektóre z tych metod usuwania, które omówiliśmy powyżej.
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); } }
Wynik:
Initial ArrayList: [Delhi, Bombaj, Chennai, Kalkuta, Pune, Hyderabad
ArrayList po usunięciu elementu pod indeksem 2: [Delhi, Mumbai, Kalkuta, Pune, Hyderabad]
ArrayList po usunięciu elementu -> Kalkuta: [Delhi, Mumbai, Pune, Hyderabad]
ArrayList po wywołaniu funkcji removeAll: [Mumbai, Pune]
ArrayList rozmiar (długość)
Prototyp: rozmiar int ()
Parametry: ZERO
Wartość zwracana: int => Liczba elementów w ArrayList.
Opis: Zwraca całkowitą liczbę elementów lub długość ArrayList.
Zapewnij pojemność
Prototyp: void zapewniaCapacity (int minCapacity)
Parametry: minCapacity => Minimalna pojemność wymagana dla ArrayList.
Wartość zwracana: unieważnić
Opis: Zwiększa pojemność ArrayList, aby zapewnić minCapacity.
trimToSize
Prototyp: void trimToSize ()
Parametry: ZERO
Wartość zwracana: unieważnić
Opis: Przycina pojemność ArrayList do rozmiaru lub liczby elementów znajdujących się na liście.
Poniższy przykład programowania demonstruje metody size (), sureCapacity () 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 + ' '); } } }
Wynik:
Rozmiar początkowy: 0
Lista oryginalna: [2, 4, 6, 8, 10]
ArrayList Rozmiar po operacji dodania: 5
ArrayList Size po wywołaniu secureCapacity () i dodaniu operacji: 7
ArrayList Size po operacji trimToSize (): 7
ArrayList finał:
2 4 6 8 10 12 14
ArrayList zawiera
Prototyp: boolean zawiera (obiekt o)
Parametry: o => Element, który ma zostać sprawdzony, jeśli występuje w ArrayList.
Wartość zwracana: true => Jeśli ArrayList zawiera element o.
Opis: Sprawdza, czy lista zawiera dany element „o”. Zwraca wartość true, jeśli element jest obecny.
Używamy metody „zawiera” w poniższym programie.
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')); } }
Wynik:
ArrayList zawiera („Red Green”): false
ArrayList zawiera („Blue”): true
ArrayList zawiera („Yellow”): false
ArrayList zawiera („White”): true
Jak pokazano na powyższym wyjściu, metoda „zawiera” sprawdza, czy podany argument występuje w tablicy ArrayList i zwraca wartość true lub false.
ArrayList get
Prototyp: E get (indeks int)
Parametry: index => Indeks, w którym element ma zostać pobrany z ArrayList.
Wartość zwracana: E => Wartość elementu w podanym indeksie w ArrayList.
Opis: Zwraca element listy obecny na pozycji określonej przez „indeks”.
Wyjątki: IndexOutOfBoundsException => Jeśli indeks jest poza zakresem.
Zestaw ArrayList (Zastąp element)
Prototyp: Zbiór E (indeks int, element E)
Parametry: index => Indeks, przy którym element ma zostać wymieniony.
Element => Nowy element do ustawienia pod określonym indeksem.
Wartość zwracana: E => Element zastępowany operacją set.
Opis: Ustawia wartość elementu przy danym „indeksie” na nową wartość podaną przez „element”.
Wyjątki: IndexOutOfBoundsException => Jeśli indeks jest poza zakresem
Poniższy program w języku Java używa metody get () i set () do pobierania i zastępowania wartości w tablicy 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)); } }
Wynik:
Wpis w indeksie 2 przed wezwaniem do ustawienia: niebieski
Wpis pod indeksem 2 po wezwaniu do ustawienia: żółty
ArrayList wyczyść
Prototyp: void clear ()
Parametry: ZERO
Wartość zwracana: unieważnić
Opis: Czyści listę, usuwając wszystkie elementy z listy.
ArrayList isEmpty
Prototyp: boolean isEmpty ()
Parametry: ZERO
Wartość zwracana: true => jeśli lista jest pusta
Opis: Sprawdza, czy podana lista jest pusta.
Funkcje Clear () i isEmpty () przedstawiono poniżej.
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()); } }
Wynik:
The ArrayList: [czerwony, zielony, niebieski, biały]
Czy ArrayList jest pusta po clear ()? :prawdziwe
ArrayList indexOf
Prototyp: int indexOf (Object o)
Parametry: o => Element, którego indeks znajduje się w ArrayList.
Wartość zwracana: int => Indeks pierwszego wystąpienia elementu na liście.
Opis: Zwraca indeks pierwszego wystąpienia elementu o na liście. -1, jeśli element o nie występuje na liście.
ArrayList lastIndexOf
Prototyp: int lastIndexOf (obiekt o)
Parametry: o => Element do wyszukania.
Wartość zwracana: int => Indeks ostatniego wystąpienia elementu na liście.
Opis: Zwraca indeks ostatniego wystąpienia określonego elementu o na liście. -1, jeśli elementu nie ma na liście.
Poniższy program w języku Java demonstruje metody indexOf i lastIndexOf klasy 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)); } }
Wynik:
The 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
ArrayList toArray
Prototyp: Obiekt [] toArray ()
Parametry: ZERO
Wartość zwracana: Obiekt [] => tablica. Ta zwrócona tablica zawiera wszystkie elementy listy we właściwej kolejności.
Opis: Konwertuje podaną listę na tablicę.
Prototyp: T [] toArray (T [] a)
Parametry: a => Array do przechowywania elementów listy. Jeśli rozmiar tablicy nie jest wystarczający dla elementów listy, tworzona jest inna tablica tego samego typu co a do przechowywania elementów.
Wartość zwracana: T [] => Tablica zawierająca wszystkie elementy listy.
Opis: Konwertuje daną listę na tablicę typu podanego przez.
Wyjątki: ArrayStoreException => Jeśli istnieje niezgodność typu środowiska wykonawczego tablicy i typu środowiska wykonawczego lub nadtypu jej elementów.
NullPointerException => Podana tablica ma wartość null
Poniższy program w języku Java demonstruje metodę toArray klasy 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)); } }
Wynik:
ArrayList: [10, 20, 30, 40, 50]
Tablica z ArrayList: [10, 20, 30, 40, 50]
Klon ArrayList
Prototyp: Klon obiektu ()
Parametry: ZERO
Wartość zwracana: Object => Klon instancji ArrayList.
Opis: Tworzy płytką kopię danej 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); } }
Wynik:
Original ArrayList: [Jabłko, Pomarańcza, Melon, Winogrona]
Cloned ArrayList: [Apple, Orange, Melon, Grapes]
Oryginalna lista ArrayList po dodaniu i usunięciu: [jabłko, melon, winogrona, mango]
Cloned ArrayList po zmianie oryginału: [Apple, Orange, Melon, Grapes]
Z powyższego wyniku programu widać, że sklonowana ArrayList jest płytką kopią oryginalnej ArrayList. Oznacza to, że po zmianie oryginalnej ArrayList zmiany te nie są odzwierciedlane w sklonowanej ArrayList, ponieważ nie współdzielą lokalizacji pamięci każdego elementu.
Aby wykonać głęboką kopię Array, należy przejść przez oryginalną ArrayList, a każdy z jej elementów musi zostać skopiowany do docelowej ArrayList.
ArrayList subList
Prototyp: List subList (int fromIndex, int toIndex)
Parametry: fromIndex => Początkowy indeks zakresu (włącznie)
toIndex => Końcowy indeks zakresu (wyłączny)
Wartość zwracana: Lista => Podlista listy w podanym zakresie.
Opis: Zwraca listę podrzędną z podanego zakresu, od indeksu do indeksu dla podanej listy. Zauważ, że ta podlista lub widok listy w podanym zakresie obsługuje wszystkie operacje obsługiwane przez listę. Żaden widok nie jest zwracany, jeśli fromIndex = toIndex.
Wyjątki: IndexOutOfBoundsException => Zgłaszane, gdy toIndex jest poza zakresem.
IllegalArgumentException => If fromIndex> toIndex, tj. Indeksy są niesprawne.
Zobaczmy przykład metody subList.
import java.util.ArrayList; import java.util.List; class Main{ public static void main(String a[]){ //create and initialize the ArrayList ArrayList intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); intList.add(30); intList.add(35); intList.add(40); intList.add(45); intList.add(50); //print the ArrayList System.out.println('Original ArrayList: '+intList); //create a sublist for the given ArrayList ArrayList sub_ArrayList = new ArrayList(intList.subList(2, 6)); //print the sublist System.out.println('Sublist of given ArrayList: '+sub_ArrayList); } }
Wynik:
Original ArrayList: [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
Podlista podanej ArrayList: [15, 20, 25, 30]
ArrayList retainAll
Prototyp: boolean retainAll (kolekcja c)
Parametry: c => Kolekcja z elementami, które mają zostać zachowane na liście.
Wartość zwracana: true => Jeśli ArrayList zmieniło się w wyniku operacji.
Opis: Zachowuje te elementy na liście, które pasują do elementów w danej kolekcji c.
Wyjątki: ClassCastException => Typ kolekcji i typ listy nie są zgodne
NullPointerException => Podana kolekcja ma wartość null lub lista zawiera element o wartości null, a kolekcja nie zezwala na wartości null.
Poniższy program demonstruje metodę 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); } }
Wynik:
Original ArrayList: [czerwony, zielony, niebieski, żółty]
Elementy kolekcji, które mają zostać zachowane na liście: [czerwony, niebieski]
ArrayList po wywołaniu retainAll: [Red, Blue]
ArrayList Iterator
Prototyp: Iterator iterator ()
Parametry: ZERO
Wartość zwracana: Iterator => iterator po elementach listy.
Opis: Zwraca iterator, aby przejść przez elementy listy w odpowiedniej kolejności.
ArrayList listIterator
JA.
Prototyp: ListIterator listIterator ()
Parametry: ZERO
Wartość zwracana: ListIterator => listIterator nad elementami listy.
Opis: Zwraca iterator listy, aby przejść przez elementy podanej listy.
II.
Prototyp: ListIterator listIterator (indeks int)
Parametry: index => Pozycja pierwszego elementu w listIterator.
Wartość zwracana: ListIterator => ListIterator dla listy z określonego indeksu.
Opis: Zwraca iterator listy, zaczynając od określonej pozycji „indeks”, aby przejść przez elementy podanej listy.
Wyjątki: IndexOutOfBoundsException => Podany indeks jest poza zakresem.
Przykład metod 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() + ' '); } } }
Wynik:
Wyświetl zawartość za pomocą metody Iterator ():
Bombaj Pune Hyderabad Delhi
Wyświetl zawartość za pomocą metody listIterator ():
Bombaj Pune Hyderabad Delhi
Dodaj tablicę do ArrayList w Javie
ArrayList obsługuje metodę addAll w celu dodania elementów kolekcji do ArrayList. W podobny sposób możesz również dodać Array do ArrayList. Odbywa się to za pomocą metody „Collections.addAll”.
Przykład dodawania Array do 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); } }
Wynik:
Initial ArrayList: [Delhi, Bombaj, Chennai, Kalkuta]
ArrayList po dodaniu tablicy: [Delhi, Mumbai, Chennai, Kalkuta, Cochin, Goa]
Sortuj ArrayList w Javie
ArrayList używa metody Collections.sort do sortowania swoich elementów. Domyślnie lista jest sortowana rosnąco według metody Collections.sort. Jeśli ArrayList ma być sortowane w kolejności malejącej, należy podać parametr „Collections.reverseOrder ()” metodzie sortowania.
Poniżej podano program do sortowania ArrayList w porządku rosnącym i malejącym:
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); } }
Wynik:
Initial ArrayList: [czerwony, zielony, niebieski, żółty]
ArrayList posortowane w porządku rosnącym:
[Niebieski, zielony, czerwony, żółty]
ArrayList posortowane malejąco:
[Żółty, czerwony, zielony, niebieski]
W przypadku, gdy ArrayList zawiera inne obiekty klasy jako elementy, możesz skorzystać z interfejsów Porównywalny i Komparator. Więcej szczegółów na temat interfejsów zostanie omówionych w naszych późniejszych tutorialach.
Odwróć ArrayList w Javie
Możesz także odwrócić ArrayList w Javie. Jedną z metod jest użycie tradycyjnej metody przechodzenia przez ArrayList w odwrotnej kolejności i skopiowanie każdego elementu do nowej ArrayList.
Inną metodą jest użycie klasy Collections, która udostępnia metodę „odwrotną” używaną do cofania kolekcji.
Program do odwracania ArrayList przy użyciu klasy Collections jest podany poniżej.
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); } }
Wynik:
Initial ArrayList: [1, 3, 5, 7, 9]
Reversed ArrayList: [9, 7, 5, 3, 1]
Usuń duplikaty z ArrayList w Javie
Aby usunąć duplikaty z ArrayList, możesz ponownie skorzystać z tradycyjnej metody używania iteratora do przechodzenia przez ArrayList i zapisywania tylko pierwszego wystąpienia elementu w innej ArrayList.
Jeszcze inną metodą jest użycie metody „wyraźnej ()” klasy stream (). Ta metoda zwraca strumień różnych elementów. Funkcja stream () jest dostępna w Javie od wersji Java 8.
Implementację metody stream () .distinct () podano poniżej:
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); } }
Wynik:
Original ArrayList: [1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8]
ArrayList bez duplikatów: [1, 2, 3, 5, 6, 7, 8]
Shuffle (Randomize) An ArrayList w Javie
Możesz także „tasować” lub losowo zmieniać elementy ArrayList. Odbywa się to za pomocą metody Collections.shuffle (). Korzystając z tej metody, możesz albo przetasować ArrayList z domyślnymi ustawieniami, albo podać funkcję random (), która będzie losować elementy zgodnie z podaną losową wartością.
Program w języku Java umożliwiający osiągnięcie tego celu znajduje się poniżej.
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); } }
Wynik:
Original ArrayList: [wschód, zachód, północ, południe, południowy zachód, północny wschód] Shuffled ArrayList without Random (): [północ, północny wschód, wschód, południowy zachód, południe, zachód]
Shuffled ArrayList with Random (): [południe, wschód, północ, północny wschód, zachód, południowy zachód]
Shuffled ArrayList with Random (2): [południowy zachód, południe, wschód, północny wschód, północ, zachód]
Często Zadawane Pytania
P 1) Jaka jest różnica między kontenerami homogenicznymi i heterogenicznymi w Javie?
najlepsze aplikacje do szpiegowania kogoś
Odpowiedź: Kontenery jednorodne zawierają obiekty / elementy tego samego typu. Z drugiej strony heterogeniczne pojemniki mają obiekty mieszanego typu.
Pytanie nr 2) Czy ArrayList w Javie jest heterogeniczne?
Odpowiedź: Tak. Ponieważ ArrayLists obsługują typy ogólne, a zatem wymazywanie typów, może zawierać obiekty mieszane, gdy jest zaimplementowany jako ogólna ArrayList.
Pytanie 3) Czy ArrayList może przechowywać int?
Odpowiedź: Nie. ArrayLists nie może przechowywać wartości takich jak int, ale może przechowywać obiekty typu Integer, ponieważ ArrayLists mogą zawierać tylko obiekty. Dlatego do przechowywania typów pierwotnych należy używać klas opakowujących, takich jak Integer dla liczb całkowitych.
Pytanie 4) Co się dzieje, gdy ArrayList jest pełny?
Odpowiedź: Każdy obiekt ArrayList ma funkcję o nazwie „pojemność”. Gdy ArrayList jest pełna, pojemność ArrayList zwiększa się automatycznie, aby zrobić miejsce na więcej elementów.
Pytanie 5) Jaka jest różnica między metodami removeAll i retainAll w ArrayList?
Odpowiedź: Metody ArrayList „removeAll” i „retainAll” zachowują się przeciwnie.
Podczas gdy metoda removeAll usuwa wszystkie elementy z listy, które pasują do kolekcji przekazanej jako argument do tej metody, z drugiej strony retainAll zachowuje wszystkie elementy na liście, które pasują do kolekcji.
Wniosek
W tym samouczku szczegółowo omówiliśmy metody ArrayList na przykładzie.
Rozważaliśmy również kilka specjalnych przypadków, takich jak dodanie elementów na początek listy. Omówiliśmy również inne operacje na ArrayList, takie jak sortowanie, cofanie i tasowanie ArrayList.
W naszym nadchodzącym samouczku omówimy niektóre konwersje ArrayList.
=> Obejrzyj serię prostych szkoleń dotyczących języka Java.
rekomendowane lektury
- Samouczek dotyczący refleksji w języku Java z przykładami
- Samouczek dotyczący ciągów Java | Metody ciągów Java z przykładami
- Metody listy Java - Sortuj listę, Zawiera, Dodaj listę, Usuń listę
- Java ArrayList - jak zadeklarować, zainicjować i wydrukować ArrayList
- Java ArrayList Konwersje do innych kolekcji
- Samouczek Java SWING: kontener, komponenty i obsługa zdarzeń
- Odwróć tablicę w Javie - 3 metody z przykładami
- Samouczek JAVA dla początkujących: ponad 100 praktycznych samouczków wideo Java