Metody ArrayList w Javie

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.

Java ArrayList_Methods

W tym samouczku szczegółowo omówimy te metody z prostymi przykładami programowania.

Czego się nauczysz:

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.
Dodaj	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.
Dodać wszystko	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 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.
usunąć	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ę.
toArray	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

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

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.

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]

Dane wyjściowe Java ArrayList addAll

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]

Wyjście - ArrayList dodaj na początek

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]

Output- ArrayList removeAll range

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

Wyjście - rozmiar listy ArrayList (długość)

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

Wyjście - ArrayList zawiera

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

Wynik

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

Dane wyjściowe - isEmpty ArrayList

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

Wynik

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]

Dane wyjściowe - toArray ArrayList

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]

wyjście - klon arraylist

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]

Wynik

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]

Dane wyjściowe - metoda retailAll

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

Wyjście - metody Iterator i listIterator

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]

dane wyjściowe - Dodaj tablicę do tablicy Arraylist w Javie

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]

Wyjście - sortuj arraylistę w Javie

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]

Wyjście - Reverse i ArrayList

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]

Wyjście - Usuń duplikaty z ArrayList

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]

Wyjście - Shuffle (Randomize) an ArrayList

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.

Metody ArrayList w Javie - samouczek z przykładowymi programami