Jawa Lista tablic klasa używa a dynamiczny szyk do przechowywania elementów. To jest jak tablica, ale istnieje brak limitu rozmiaru . Elementy możemy dodawać lub usuwać w dowolnym momencie. Jest więc znacznie bardziej elastyczny niż tradycyjna tablica. Znajduje się w Java.util pakiet. To jest jak Vector w C++.

ArrayList w Javie może również zawierać zduplikowane elementy. Implementuje interfejs List, dzięki czemu możemy tutaj używać wszystkich metod interfejsu List. ArrayList wewnętrznie utrzymuje kolejność wstawiania.

Dziedziczy klasę AbstractList i implementuje Interfejs listy .

Ważne punkty dotyczące klasy Java ArrayList to:

• Klasa Java ArrayList może zawierać zduplikowane elementy.
• Klasa Java ArrayList utrzymuje kolejność wstawiania.
• Klasa Java ArrayList nie jest zsynchronizowane .
• Java ArrayList umożliwia dostęp losowy, ponieważ tablica działa na podstawie indeksu.
• W ArrayList manipulacja jest nieco wolniejsza niż w przypadku LinkedList w Javie, ponieważ usunięcie dowolnego elementu z listy tablic wymaga wielu przesunięć.
• Nie możemy utworzyć listy tablicowej typów pierwotnych, takich jak int, float, char itp. W takich przypadkach wymagane jest użycie wymaganej klasy wrappera. Na przykład:

 ArrayList al = ArrayList(); // does not work ArrayList al = new ArrayList(); // works fine 

• Java ArrayList jest inicjowany przez rozmiar. Rozmiar na liście tablic jest dynamiczny i różni się w zależności od elementów dodawanych lub usuwanych z listy.

Hierarchia klasy ArrayList

Jak pokazano na powyższym diagramie, klasa Java ArrayList jest rozwinięciem klasy AbstractList, która implementuje interfejs List. Interfejs List rozszerza Kolekcja oraz Iterowalne interfejsy w porządku hierarchicznym.

Deklaracja klasy ArrayList

Zobaczmy deklarację klasy java.util.ArrayList.

 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable 

Konstruktorzy ArrayList

Metody ArrayList

Java nieogólna vs. Kolekcja ogólna

Struktura kolekcji Java nie była ogólna przed JDK 1.5. Od wersji 1.5 jest to rozwiązanie ogólne.

Nowa ogólna kolekcja Java pozwala na posiadanie tylko jednego typu obiektu w kolekcji. Teraz jest bezpieczny dla typów, więc rzutowanie typów nie jest wymagane w czasie wykonywania.

Zobaczmy stary, nieogólny przykład tworzenia kolekcji Java.

 ArrayList list=new ArrayList();//creating old non-generic arraylist 

Zobaczmy nowy ogólny przykład tworzenia kolekcji Java.

 ArrayList list=new ArrayList();//creating new generic arraylist 

W kolekcji ogólnej typ określamy w nawiasach kątowych. Teraz ArrayList jest zmuszony zawierać tylko określony typ obiektu. Jeśli spróbujesz dodać inny typ obiektu, otrzymasz błąd w czasie kompilacji .

Aby uzyskać więcej informacji na temat ogólnych rozwiązań Java, kliknij tutaj Samouczek dotyczący języka Java .

Przykład Java ArrayList

Nazwa pliku: ArrayListExample1.java

 import java.util.*; public class ArrayListExample1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Printing the arraylist object System.out.println(list); } } 

Wyjście:

[Mango, Apple, Banana, Grapes] 

Iterowanie ArrayList za pomocą Iteratora

Zobaczmy przykład przeglądania elementów ArrayList przy użyciu interfejsu Iteratora.

Nazwa pliku: ArrayListExample2.java

zaczyna się od Javy

 import java.util.*; public class ArrayListExample2{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through Iterator Iterator itr=list.iterator();//getting the Iterator while(itr.hasNext()){//check if iterator has the elements System.out.println(itr.next());//printing the element and move to next } } } 

Wyjście:

Mango Apple Banana Grapes 

Iterowanie ArrayList przy użyciu pętli For-each

Zobaczmy przykład przechodzenia przez elementy ArrayList przy użyciu pętli for-each

Nazwa pliku: ArrayListExample3.java

 import java.util.*; public class ArrayListExample3{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through for-each loop for(String fruit:list) System.out.println(fruit); } } 

Wyjście:

Mango Apple Banana Grapes 

Pobierz i ustaw ArrayList

The metoda get(). zwraca element o określonym indeksie, podczas gdy metoda set(). zmienia element.

Nazwa pliku: ArrayListExample4.java

 import java.util.*; public class ArrayListExample4{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Mango'); al.add('Apple'); al.add('Banana'); al.add('Grapes'); //accessing the element System.out.println('Returning element: '+al.get(1));//it will return the 2nd element, because index starts from 0 //changing the element al.set(1,'Dates'); //Traversing list for(String fruit:al) System.out.println(fruit); } } 

Wyjście:

Returning element: Apple Mango Dates Banana Grapes 

Jak sortować ArrayList

The Java.util pakiet udostępnia klasę użyteczności Kolekcje , który ma statyczną metodę sort(). Używając Kolekcje.sort() metodę, możemy łatwo posortować ArrayList.

Nazwa pliku: SortArrayList.java

 import java.util.*; class SortArrayList{ public static void main(String args[]){ //Creating a list of fruits List list1=new ArrayList(); list1.add('Mango'); list1.add('Apple'); list1.add('Banana'); list1.add('Grapes'); //Sorting the list Collections.sort(list1); //Traversing list through the for-each loop for(String fruit:list1) System.out.println(fruit); System.out.println('Sorting numbers...'); //Creating a list of numbers List list2=new ArrayList(); list2.add(21); list2.add(11); list2.add(51); list2.add(1); //Sorting the list Collections.sort(list2); //Traversing list through the for-each loop for(Integer number:list2) System.out.println(number); } } 

Wyjście:

Apple Banana Grapes Mango Sorting numbers... 1 11 21 51 

Sposoby iteracji elementów kolekcji w Javie

Elementy kolekcji można przeglądać na różne sposoby:

1. Przez interfejs Iteratora.
2. Przez pętlę for-each.
3. Przez interfejs ListIterator.
4. Przez pętlę for.
5. Za pomocą metody forEach().
6. Za pomocą metody forEachRemaining().

Iterowanie kolekcji pozostałymi sposobami

Zobaczmy przykład przechodzenia przez elementy ArrayList innymi sposobami

Nazwa pliku: ArrayList4.java

 import java.util.*; class ArrayList4{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add(&apos;Ravi&apos;);//Adding object in arraylist list.add(&apos;Vijay&apos;); list.add(&apos;Ravi&apos;); list.add(&apos;Ajay&apos;); System.out.println(&apos;Traversing list through List Iterator:&apos;); //Here, element iterates in reverse order ListIterator list1=list.listIterator(list.size()); while(list1.hasPrevious()) { String str=list1.previous(); System.out.println(str); } System.out.println(&apos;Traversing list through for loop:&apos;); for(int i=0;i<list.size();i++) { system.out.println(list.get(i)); } system.out.println('traversing list through foreach() method:'); the method is a new feature, introduced in java 8. list.foreach(a->{ //Here, we are using lambda expression System.out.println(a); }); System.out.println(&apos;Traversing list through forEachRemaining() method:&apos;); Iterator itr=list.iterator(); itr.forEachRemaining(a-&gt; //Here, we are using lambda expression { System.out.println(a); }); } } </list.size();i++)>

Wyjście:

Traversing list through List Iterator: Ajay Ravi Vijay Ravi Traversing list through for loop: Ravi Vijay Ravi Ajay Traversing list through forEach() method: Ravi Vijay Ravi Ajay Traversing list through forEachRemaining() method: Ravi Vijay Ravi Ajay 

Obiekty klas zdefiniowane przez użytkownika w Java ArrayList

Zobaczmy przykład, w którym przechowujemy obiekt klasy Student na liście tablic.

Nazwa pliku: ArrayList5.java

 class Student{ int rollno; String name; int age; Student(int rollno,String name,int age){ this.rollno=rollno; this.name=name; this.age=age; } } 

 import java.util.*; class ArrayList5{ public static void main(String args[]){ //Creating user-defined class objects Student s1=new Student(101,'Sonoo',23); Student s2=new Student(102,'Ravi',21); Student s2=new Student(103,'Hanumat',25); //creating arraylist ArrayList al=new ArrayList(); al.add(s1);//adding Student class object al.add(s2); al.add(s3); //Getting Iterator Iterator itr=al.iterator(); //traversing elements of ArrayList object while(itr.hasNext()){ Student st=(Student)itr.next(); System.out.println(st.rollno+' '+st.name+' '+st.age); } } } 

Wyjście:

 101 Sonoo 23 102 Ravi 21 103 Hanumat 25 

Przykład serializacji i deserializacji Java ArrayList

Zobaczmy przykład serializacji obiektu ArrayList, a następnie deserializacji.

Nazwa pliku: ArrayList6.java

 import java.io.*; import java.util.*; class ArrayList6 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); try { //Serialization FileOutputStream fos=new FileOutputStream('file'); ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeObject(al); fos.close(); oos.close(); //Deserialization FileInputStream fis=new FileInputStream('file'); ObjectInputStream ois=new ObjectInputStream(fis); ArrayList list=(ArrayList)ois.readObject(); System.out.println(list); }catch(Exception e) { System.out.println(e); } } } 

Wyjście:

 [Ravi, Vijay, Ajay] 

Przykład Java ArrayList do dodawania elementów

Tutaj widzimy różne sposoby dodawania elementu.

Nazwa pliku: ArrayList7.java

 import java.util.*; class ArrayList7{ public static void main(String args[]){ ArrayList al=new ArrayList(); System.out.println('Initial list of elements: '+al); //Adding elements to the end of the list al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After invoking add(E e) method: '+al); //Adding an element at the specific position al.add(1, 'Gaurav'); System.out.println('After invoking add(int index, E element) method: '+al); ArrayList al2=new ArrayList(); al2.add('Sonoo'); al2.add('Hanumat'); //Adding second list elements to the first list al.addAll(al2); System.out.println('After invoking addAll(Collection c) method: '+al); ArrayList al3=new ArrayList(); al3.add('John'); al3.add('Rahul'); //Adding second list elements to the first list at specific position al.addAll(1, al3); System.out.println('After invoking addAll(int index, Collection c) method: '+al); } } 

Wyjście:

Initial list of elements: [] After invoking add(E e) method: [Ravi, Vijay, Ajay] After invoking add(int index, E element) method: [Ravi, Gaurav, Vijay, Ajay] After invoking addAll(Collection c) method: [Ravi, Gaurav, Vijay, Ajay, Sonoo, Hanumat] After invoking addAll(int index, Collection c) method: [Ravi, John, Rahul, Gaurav, Vijay, Ajay, Sonoo, Hanumat] 

Przykład Java ArrayList do usuwania elementów

Tutaj widzimy różne sposoby usuwania elementu.

Nazwa pliku: ArrayList8.java

 import java.util.*; class ArrayList8 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); al.add('Anuj'); al.add('Gaurav'); System.out.println('An initial list of elements: '+al); //Removing specific element from arraylist al.remove('Vijay'); System.out.println('After invoking remove(object) method: '+al); //Removing element on the basis of specific position al.remove(0); System.out.println('After invoking remove(index) method: '+al); //Creating another arraylist ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); //Adding new elements to arraylist al.addAll(al2); System.out.println('Updated list : '+al); //Removing all the new elements from arraylist al.removeAll(al2); System.out.println('After invoking removeAll() method: '+al); //Removing elements on the basis of specified condition al.removeIf(str -> str.contains('Ajay')); //Here, we are using Lambda expression System.out.println('After invoking removeIf() method: '+al); //Removing all the elements available in the list al.clear(); System.out.println('After invoking clear() method: '+al); } } 

Wyjście:

An initial list of elements: [Ravi, Vijay, Ajay, Anuj, Gaurav] After invoking remove(object) method: [Ravi, Ajay, Anuj, Gaurav] After invoking remove(index) method: [Ajay, Anuj, Gaurav] Updated list : [Ajay, Anuj, Gaurav, Ravi, Hanumat] After invoking removeAll() method: [Ajay, Anuj, Gaurav] After invoking removeIf() method: [Anuj, Gaurav] After invoking clear() method: [] 

Przykład metody keepAll() w języku Java ArrayList

Nazwa pliku: ArrayList9.java

 import java.util.*; class ArrayList9{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); al.retainAll(al2); System.out.println('iterating the elements after retaining the elements of al2'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Wyjście:

 iterating the elements after retaining the elements of al2 Ravi 

Przykład metody isEmpty() w języku Java ArrayList

Nazwa pliku: ArrayList4.java

 import java.util.*; class ArrayList10{ public static void main(String [] args) { ArrayList al=new ArrayList(); System.out.println('Is ArrayList Empty: '+al.isEmpty()); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After Insertion'); System.out.println('Is ArrayList Empty: '+al.isEmpty()); } } 

Wyjście:

Is ArrayList Empty: true After Insertion Is ArrayList Empty: false 

Przykład Java ArrayList: Książka

Zobaczmy przykład ArrayList, w którym dodajemy książki do listy i drukujemy wszystkie książki.

hashowanie w strukturze danych

Nazwa pliku: ArrayListExample20.java

 import java.util.*; class Book { int id; String name,author,publisher; int quantity; public Book(int id, String name, String author, String publisher, int quantity) { this.id = id; this.name = name; this.author = author; this.publisher = publisher; this.quantity = quantity; } } public class ArrayListExample20 { public static void main(String[] args) { //Creating list of Books List list=new ArrayList(); //Creating Books Book b1=new Book(101,'Let us C','Yashwant Kanetkar','BPB',8); Book b2=new Book(102,'Data Communications and Networking','Forouzan','Mc Graw Hill',4); Book b3=new Book(103,'Operating System','Galvin','Wiley',6); //Adding Books to list list.add(b1); list.add(b2); list.add(b3); //Traversing list for(Book b:list){ System.out.println(b.id+' '+b.name+' '+b.author+' '+b.publisher+' '+b.quantity); } } } 

Wyjście:

101 Let us C Yashwant Kanetkar BPB 8 102 Data Communications and Networking Forouzan Mc Graw Hill 4 103 Operating System Galvin Wiley 6 

Rozmiar i pojemność tablicy ArrayList

Rozmiar i pojemność listy tablic to dwa terminy, które początkujący uważają za mylące. Rozumiemy to w tej sekcji za pomocą kilku przykładów. Rozważ następujący fragment kodu.

Nazwa pliku: SizeCapacity.java

 import java.util.*; public class SizeCapacity { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(); System.out.println('The size of the array is: ' + al.size()); } } 

Wyjście:

 The size of the array is: 0 

Wyjaśnienie: Wynik ma sens, ponieważ nie zrobiliśmy nic z listą tablic. Teraz obserwuj następujący program.

Nazwa pliku: RozmiarPojemność1.java

 import java.util.*; public class SizeCapacity1 { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(10); System.out.println('The size of the array is: ' + al.size()); } } 

Wyjście:

 The size of the array is: 0 

Wyjaśnienie: Widzimy, że rozmiar nadal wynosi 0, a powodem tego jest to, że liczba 10 reprezentuje pojemność, a nie rozmiar. W rzeczywistości rozmiar reprezentuje całkowitą liczbę elementów znajdujących się w tablicy. Ponieważ nie dodaliśmy żadnego elementu, rozmiar listy tablic w obu programach wynosi zero.

Pojemność reprezentuje całkowitą liczbę elementów, które może zawierać lista tablic. Dlatego pojemność listy tablic jest zawsze większa lub równa rozmiarowi listy tablic. Kiedy dodajemy element do listy tablic, sprawdza on, czy rozmiar listy tablic stał się równy pojemności, czy nie. Jeśli tak, to pojemność listy tablic wzrasta. Zatem w powyższym przykładzie pojemność będzie wynosić 10, dopóki do listy nie zostanie dodanych 10 elementów. Gdy dodamy 11^telement, pojemność wzrasta. Zauważ, że w obu przykładach pojemność listy tablic wynosi 10. W pierwszym przypadku pojemność wynosi 10, ponieważ domyślna pojemność listy tablic wynosi 10. W drugim przypadku wyraźnie wspomnieliśmy, że pojemność tablicy lista to 10.

Uwaga: Nie ma żadnej standardowej metody określania, jak zwiększa się pojemność listy tablic. W rzeczywistości sposób zwiększania pojemności różni się w zależności od wersji GDK. Dlatego też należy sprawdzić sposób implementacji kodu zwiększającego pojemność w GDK. W klasie ArrayList nie ma żadnej predefiniowanej metody zwracającej pojemność listy tablic. Dlatego dla lepszego zrozumienia użyj metody pojemność() klasy Vector. Logika rozmiaru i pojemności jest taka sama w klasie ArrayList i klasie Vector.

Powiązane tematy

Jak sortować ArrayList w Javie

Różnica między Array i ArrayList

Kiedy używać ArrayList i LinkedList w Javie

Różnica między ArrayList i LinkedList

Różnica między ArrayList i Vector

Jak porównać dwie listy tablic w Javie

Jak odwrócić ArrayList w Javie

Kiedy używać ArrayList i LinkedList w Javie

Jak ustawić ArrayList tylko do odczytu

Różnica między długością tablicy i size() ArrayList w Javie

Jak zsynchronizować ArrayList w Javie

Jak przekonwertować ArrayList na Array i Array na ArrayList w Javie

Tablica vs ArrayList w Javie

ścieżka ustawiona w Javie

Jak sortować listę tablic Java w kolejności malejącej

Jak usunąć duplikaty z ArrayList w Javie