Chuyển tới nội dung
Home » Arraylist De Arraylist Java | Loop Through An Arraylist

Arraylist De Arraylist Java | Loop Through An Arraylist

ArrayList in Java Tutorial #36

Lớp ArrayList trong java

Lớp ArrayList trong java là một lớp kế thừa lớp AbstractList và triển khai của List Interface trong Collections Framework nên nó sẽ có một vài đặc điểm và phương thức tương đồng với List. ArrayList được sử dụng như một mảng động để lưu trữ các phần tử.

Những điểm cần ghi nhớ về ArrayList:

  • Lớp ArrayList trong java có thể chứa các phần tử trùng lặp.
  • Lớp ArrayList duy trì thứ tự của phần tử được thêm vào.
  • Lớp ArrayList là không đồng bộ (non-synchronized).
  • Lớp ArrayList cho phép truy cập ngẫu nhiên vì nó lưu dữ liệu theo chỉ mục.
  • Lớp ArrayList trong java, thao tác chậm vì cần nhiều sự dịch chuyển nếu bất kỳ phần tử nào bị xoá khỏi danh sách.

Các phương thức trong Java ArrayList

  • add(int index, Object element): Phương thức này được sử dụng để chèn một phần tử cụ thể vào một chỉ mục vị trí cụ thể trong danh sách.
  • add(Object o): Phương thức này được sử dụng để thêm một phần tử cụ thể vào cuối danh sách.
  • addAll(Collection C): Phương thức này được sử dụng để nối tất cả các phần tử từ một collection cụ thể vào cuối danh sách được đề cập, theo thứ tự sao cho các giá trị được trả về bởi trình lặp của collection đã chỉ định.
  • addAll(int index, Collection C): Được sử dụng để chèn tất cả các phần tử bắt đầu từ vị trí đã chỉ định từ một collection cụ thể vào danh sách được đề cập.
  • clear(): Phương thức này được sử dụng để xóa tất cả các phần tử khỏi bất kỳ danh sách nào.
  • clone(): Phương thức này được sử dụng để trả về một bản sao nông của ArrayList.
  • contains?(Object o): Trả về true nếu danh sách này chứa phần tử đã chỉ định.
  • ensureCapacity?(int minCapacity) Tăng dung lượng của cá thể ArrayList này, nếu cần, để đảm bảo rằng nó có thể chứa ít nhất số phần tử được chỉ định bởi đối số dung lượng tối thiểu.
  • forEach?(Consumer

    action) Thực hiện hành động đã cho cho từng phần tử của Iterable cho đến khi tất cả các phần tử đã được xử lý hoặc hành động đưa ra một ngoại lệ.
  • get?(int index) Trả về phần tử tại vị trí đã chỉ định trong danh sách này.
  • indexOf(Object O) Chỉ mục lần xuất hiện đầu tiên của một phần tử cụ thể được trả về hoặc -1 trong trường hợp phần tử không có trong danh sách.
  • isEmpty?() Trả về true nếu danh sách này không chứa phần tử nào.
  • lastIndexOf(Object O) Chỉ mục của lần xuất hiện cuối cùng của một phần tử cụ thể được trả về hoặc -1 trong trường hợp phần tử không có trong danh sách.
  • listIterator?() Trả về một trình lặp danh sách trên các phần tử trong danh sách này (theo trình tự thích hợp).
  • listIterator?(int index) Trả về một trình lặp danh sách trên các phần tử trong danh sách này (theo trình tự thích hợp), bắt đầu từ vị trí đã chỉ định trong danh sách.
  • remove?(int index) Xóa phần tử ở vị trí đã chỉ định trong danh sách này.
  • remove?(Object o) Loại bỏ sự xuất hiện đầu tiên của phần tử được chỉ định khỏi danh sách này, nếu nó xuất hiện.
  • removeAll?(Collection c) Xóa khỏi danh sách này tất cả các phần tử của nó được chứa trong collection đã chỉ định.
  • removeIf?(Predicate filter) Xóa tất cả các phần tử của collection này thỏa mãn vị từ đã cho.
  • removeRange?(int fromIndex, int toIndex) Xóa khỏi danh sách này tất cả các phần tử có chỉ mục nằm giữa fromIndex, bao gồm và toIndex, loại trừ.
  • keepAll?(Collection

    c) Chỉ giữ lại các phần tử trong danh sách này được chứa trong collection đã chỉ định.
  • set?(int index, E element) Thay thế phần tử ở vị trí đã chỉ định trong danh sách này bằng phần tử đã chỉ định.
  • size?() Trả về số phần tử trong danh sách này.
  • spliterator?() Tạo một Spliterator ràng buộc muộn và không nhanh trên các phần tử trong danh sách này.
  • subList?(int fromIndex, int toIndex) Trả về dạng xem của phần danh sách này giữa fromIndex, bao gồm và toIndex, loại trừ đã chỉ định.
  • toArray() Phương thức này được sử dụng để trả về một mảng chứa tất cả các phần tử trong danh sách theo đúng thứ tự.
  • toArray(Object[] O) Nó cũng được sử dụng để trả về một mảng chứa tất cả các phần tử trong danh sách này theo đúng thứ tự giống như phương thức trước đó.
  • trimToSize() Phương thức này được sử dụng để cắt bớt dung lượng của thể hiện của ArrayList theo kích thước hiện tại của danh sách.

Lưu ý: Bạn cũng có thể tạo một ArrayList chung:

ArrayList

arrli = new ArrayList

();

Một số điểm chính của ArrayList:

  1. ArrayList là Cấu trúc dữ liệu Array có thể thay đổi kích thước hoặc array có thể mở rộng số lượng phần tử.
  2. Các bản copy ArrayList được cho phép.
  3. Thứ tự chèn được giữ nguyên.
  4. Các đối tượng không đồng nhất được cho phép.
  5. Có thể chèn Null.

Hãy xem cách thực hiện một số thao tác cơ bản trên ArrayList như được liệt kê mà chúng ta sẽ thảo luận thêm bên cạnh việc triển khai mọi thao tác.

  • Thêm phần tử vào List/ Thêm phần tử
  • Thay đổi phần tử/ Đặt phần tử
  • Xóa phần tử/Xóa phần tử
  • Các phần tử lặp lại
  • lấy các phần tử
  • thêm các phần tử ở giữa hai số
  • Sắp xếp các phần tử
  • Kích thước ArrayList

Ví dụ 1: Thêm phần tử

Để thêm một phần tử vào một ArrayList, chúng ta có thể sử dụng phương thức add(). Phương thức này bị quá tải để thực hiện nhiều thao tác dựa trên các tham số khác nhau. Chúng như sau:

  • add(Object): Phương thức này được sử dụng để thêm một phần tử vào cuối ArrayList.
  • add(int index, Object): Phương thức này được sử dụng để thêm một phần tử vào một chỉ mục cụ thể trong ArrayList.

Thí dụ:

// khai bao thu vien utility classes import java.util.*; // class ArrayList_ex class ArrayList_ex { //ham main public static void main(String args[]) { //tao array voi kieu string ArrayList

al = new ArrayList<>(); //them cac element vao arraylist al.add(“element1”); al.add(“element2”); //them element tai index 1 al.add(1, “For”); //in tat ca element trong arraylist System.out.println(al); } }

Ví dụ 2: Thay đổi các phần tử

Sau khi thêm các phần tử, nếu chúng ta muốn thay đổi phần tử, có thể thực hiện bằng phương thức set(). Vì một ArrayList được lập chỉ mục, phần tử mà chúng ta muốn thay đổi được tham chiếu bởi chỉ mục của phần tử. Do đó, phương thức này lấy một chỉ mục và phần tử được cập nhật cần được chèn vào chỉ mục đó.

Thí dụ

import java.util.*; // ArrayList_ex class class ArrayList_ex { // ham main public static void main(String args[]) { //tao array voi kieu string ArrayList

al = new ArrayList<>(); //add string vao array al.add(“ArrayList_ex1”); al.add(“ArrayList_ex2”); // them object vao index 1 al.add(1, “ArrayList_ex3”); // in cac phan tu arraylist System.out.println(“Initial ArrayList ” + al); // set phan tu index 1 al.set(1, “For”); // in ra phan tu updated Arraylist System.out.println(“Updated ArrayList ” + al); } }

Ví dụ 3: Loại bỏ các phần tử

Để xóa một phần tử khỏi ArrayList, chúng ta có thể sử dụng phương thức remove(). Phương thức này bị quá tải để thực hiện nhiều thao tác dựa trên các tham số khác nhau. Chúng như sau:

remove(Object): Phương thức này được sử dụng để xóa một đối tượng khỏi ArrayList. Nếu có nhiều đối tượng như vậy, thì lần xuất hiện đầu tiên của đối tượng sẽ bị xóa.

remove(int index): Vì một ArrayList được lập chỉ mục, nên phương thức này nhận một giá trị số nguyên, đơn giản là loại bỏ phần tử có tại chỉ mục cụ thể đó trong ArrayList. Sau khi loại bỏ phần tử, tất cả các phần tử được di chuyển sang bên trái để lấp đầy khoảng trống và các chỉ số của đối tượng được cập nhật.

Thí dụ

import java.util.*; // Main class class ArrayList_ex { // Main driver method public static void main(String args[]) { // Creating an object of arraylist class ArrayList

al = new ArrayList<>(); // Adding elements to ArrayList // Custom addition al.add(“ArrayList_ex1”); al.add(“ArrayList_ex2”); // Adding element at specific index al.add(1, “For”); // Printing all elements of ArrayList System.out.println(“Initial ArrayList ” + al); // Removing element from above ArrayList al.remove(1); // Printing the updated Arraylist elements System.out.println(“After the Index Removal ” + al); // Removing this word element in ArrayList al.remove(“ArrayList_ex1”); // Now printing updated ArrayList System.out.println(“After the Object Removal ” + al); } }

Ví dụ 4: Lặp lại ArrayList

Có nhiều cách để lặp qua ArrayList. Các cách nổi tiếng nhất là sử dụng vòng lặp for cơ bản kết hợp với phương thức get() để lấy phần tử tại một chỉ mục cụ thể và vòng lặp for nâng cao.

Thí dụ

import java.util.*; // Main class class ArrayList_ex { // Main driver method public static void main(String args[]) { // Creating an Arraylist of string type ArrayList

al = new ArrayList<>(); // Adding elements to ArrayList // using standard add() method al.add(“ArrayList_ex1”); al.add(“ArrayList_ex2”); al.add(1, “For”); // Using the Get method and the // for loop for (int i = 0; i < al.size(); i++) { System.out.print(al.get(i) + ” “); } System.out.println(); // Using the for each loop for (String str : al) System.out.print(str + ” “); } }

Ví dụ 5-Lấy phần tử

/*package whatever //do not write package name here */ import java.io.*; import java.util.*; class ArrayList_ex { public static void main (String[] args) { ArrayList

list = new ArrayList(); // add the number list.add(9); list.add(5); list.add(6); System.out.println(list); // get method Integer n= list.get(1); System.out.println(“at indext 1 number is:”+n); } }

Ví dụ 6- Cộng các phần tử giữa hai số:

import java.io.*; import java.util.*; class ArrayList_ex { public static void main(String[] args) { ArrayList

list = new ArrayList(); list.add(1); list.add(2); list.add(4); System.out.println(list); // insert missing element 3 list.add(2, 3); System.out.println(list); } }

Ví dụ 7-Sắp xếp phần tử.

import java.io.*; import java.util.*; class ArrayList_ex { public static void main(String[] args) { ArrayList

list = new ArrayList(); list.add(2); list.add(4); list.add(3); list.add(1); System.out.println(“Before sorting list:”); System.out.println(list); Collections.sort(list); System.out.println(“after sorting list:”); System.out.println(list); } }

Ví dụ 8-Kích thước các phần tử:

import java.io.*; import java.util.*; class ArrayList_ex { public static void main(String[] args) { ArrayList

list = new ArrayList(); list.add(1); list.add(2); list.add(3); list.add(4); int b = list.size(); System.out.println(“The size is :” + b); } }

Gán giá trị cho ArrayList trong java?

Xin chào mọi người. em có 1 arraylist bao gồm các đối tượng (data) của em định nghĩa. giờ em muốn tạo 1 arraylist thứ 2 để copy toàn bộ của arraylist đầu tiên. nhưng khi em thay đổi giá trị của thằng thứ 2 thì thằng đầu tiên cũng bị thay đổi theo. Vậy làm thế nào để copy mà nó không thay đổi giá trị của mảng gốc ạ?

em đã thử dùng cả 2 cách như trên nhưng không hiệu quả. rất mong dc sư giúp đỡ của mọi người em cảm ơn ạ!


ArrayList

arr2 = new ArrayList

(arr); //tạo arr2 truyền tham số là arr //hoặc arr2 = arr; arr2.get(0).ThoiGianDen--; for(int i = 0; i < arr.size(); i++) //xuất arr { arr.get(i).Xuat(); }


Bình luận

Do ArrayList chỉ chứa các object mà object là kiểu tham chiếu nên cho dù có sao chép (tạo mới vùng nhớ cho ArrayList) thì dữ liệu bên trong (các object) cũng tham chiếu đến nhau thôi. Để giải quyết vấn đề hoặc là bạn tìm cấu trúc dữ liệu khác để lưu trữ hoặc bạn có thể xử lý như sau:

+ Trong lớp của bạn, bạn tạo ra 1 hàm clone mục đích là để sao chép các đối tượng theo cách của bạn. Nhớ là hàm này để public và hàm này là override cho hàm clone của lớp Object.

+ Duyệt qua các phần tử của ArrayList ban đầu sau đó add mới vào ArrayList copy.

Đây là code minh hoạ của mình:


public class Test { public static void main(String[] args) { ArrayList

arr = new ArrayList

(); arr.add(new ObjectClass(2, 3)); arr.add(new ObjectClass(4, 5)); ArrayList

arr2 = new ArrayList

(); // Duyệt qua tất cả các phần tử của arr for (ObjectClass item: arr) { arr2.add(item.clone()); // thêm object đã được tạo mới (clone) vào arr2 } arr2.get(0).x--; System.out.println("arr.x: " + arr.get(0).x + " arr2.x: " + arr2.get(0).x); } } // lớp do mình tạo ra class ObjectClass { public ObjectClass(int x, int y) { this.x = x; this.y = y; } public int x; public int y; @Override public ObjectClass clone() { // hàm clone mình tự viết mục đích là tạo ra đối tượng mới và sao chép nội dung của đối tượng cũ. return new ObjectClass(this.x, this.y); } }




Bạn dùng List thay cho ArrayList thì sẽ ra ngay: Ví dụ:

List

l1 = new ArrayList

(); l1.add(“Hello”); l1.add(“World”); List

l2 = new ArrayList

(l1); l2.add(“Everybody”); Log.e(“log”, String.valueOf(l2.size()));//=>kq: 3 Log.e(“log”, String.valueOf(l1.size()));//=>kq: 2



l2.set(1, “Change”); Log.e(“log”, l1.get(1));//=>kq: “World” Log.e(“log”, l2.get(1));//=> “Change”

ArrayList in Java Tutorial #36
ArrayList in Java Tutorial #36

Các tính năng quan trọng của ArrayList:

  • ArrayList kế thừa lớp AbstractList và triển khai List interface.
  • ArrayList được khởi tạo theo kích thước. Tuy nhiên, kích thước sẽ tự động tăng lên nếu collection tăng lên hoặc thu nhỏ lại nếu các đối tượng bị xóa khỏi collection.
  • Java ArrayList cho phép chúng ta truy cập ngẫu nhiên vào danh sách.
  • ArrayList không thể được sử dụng cho các kiểu nguyên thủy, như int, char, v.v. Chúng ta cần một class bao bọc cho những trường hợp như vậy.
  • ArrayList trong Java có thể được xem như một vector trong C++.
  • ArrayList không được Synchronized. Lớp Synchronized tương đương của nó trong Java là Vector.

Hãy hiểu sâu hơn về ArrayList trong Java. Nhìn vào hình ảnh dưới đây:

Trong hình minh họa ở trên, AbstractList, CopyOnWriteArrayList và AbstractSequentialList là các lớp triển khai list interface. Một chức năng riêng biệt được thực hiện trong mỗi class được đề cập.

  • AbstractList: class này được sử dụng để triển khai một danh sách không thể sửa đổi, mà danh sách này chỉ cần mở rộng class AbstractList này và chỉ triển khai các phương thức get() và size().
  • CopyOnWriteArrayList: class này implement list interface. Đây là phiên bản nâng cao của ArrayList trong đó tất cả các sửa đổi (thêm, đặt, xóa, v.v.) được triển khai bằng cách tạo một bản sao mới của danh sách.
  • AbstractSequentialList: class này triển khai interface collection và class AbstractCollection. Class này được sử dụng để implement một danh sách không thể sửa đổi, mà danh sách này chỉ cần mở rộng Lớp AbstractList này và chỉ triển khai các phương thức get() và size().

Synchronizing Access to an ArrayList

The ArrayList class is not synchronized. If multiple threads try to modify an ArrayList at the same time then the final result becomes not-deterministic because one thread might override the changes done by another thread.

Example Demonstrating ArrayList’s unpredictable behavior in multi-threaded environments

The following example shows what happens when multiple threads try to modify an ArrayList at the same time.


import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class UnsafeArrayListExample { public static void main(String[] args) throws InterruptedException { List

unsafeArrayList = new ArrayList<>(); unsafeArrayList.add(1); unsafeArrayList.add(2); unsafeArrayList.add(3); // Create a thread pool of size 10 ExecutorService executorService = Executors.newFixedThreadPool(10); // Create a Runnable task that increments each element of the ArrayList by one Runnable task = () -> { incrementArrayList(unsafeArrayList); }; // Submit the task to the executor service 100 times. // All the tasks will modify the ArrayList concurrently for(int i = 0; i < 100; i++) { executorService.submit(task); } executorService.shutdown(); executorService.awaitTermination(60, TimeUnit.SECONDS); System.out.println(unsafeArrayList); } // Increment all the values in the ArrayList by one private static void incrementArrayList(List

unsafeArrayList) { for(int i = 0; i < unsafeArrayList.size(); i++) { Integer value = unsafeArrayList.get(i); unsafeArrayList.set(i, value + 1); } } }


The final output of the above program should be equal to

[101, 102, 103]

because we’re incrementing the values in the ArrayList 100 times. But if you run the program, it will produce different output every time it is run –


# Output [96, 96, 98]

Try running the above program multiple times and see how it produces different outputs. To learn more about such issues in multi-threaded programs, check out my article on Java Concurrency Issues and Thread Synchronization.

Example demonstrating how to synchronize concurrent modifications to an ArrayList

All right! Now let’s see how we can synchronize access to the

ArrayList

in multi-threaded environments.

The following example shows the synchronized version of the previous example. Unlike the previous program, the output of this program is deterministic and will always be the same.


import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class SynchronizedArrayListExample { public static void main(String[] args) throws InterruptedException { List

safeArrayList = Collections.synchronizedList(new ArrayList<>()); safeArrayList.add(1); safeArrayList.add(2); safeArrayList.add(3); // Create a thread pool of size 10 ExecutorService executorService = Executors.newFixedThreadPool(10); // Create a Runnable task that increments each element of the ArrayList by one Runnable task = () -> { incrementArrayList(safeArrayList); }; // Submit the task to the executor service 100 times. // All the tasks will modify the ArrayList concurrently for(int i = 0; i < 100; i++) { executorService.submit(task); } executorService.shutdown(); executorService.awaitTermination(60, TimeUnit.SECONDS); System.out.println(safeArrayList); } // Increment all the values in the ArrayList by one private static void incrementArrayList(List

safeArrayList) { synchronized (safeArrayList) { for (int i = 0; i < safeArrayList.size(); i++) { Integer value = safeArrayList.get(i); safeArrayList.set(i, value + 1); } } } }



# Output [101, 102, 103]

The above example uses

Collections.synchronizedList()

method to get a synchronized view of the ArrayList.

Moreover, the modifications to the ArrayList inside the

incrementArrayList()

method is wrapped inside a

synchronized

block. This ensures that no two threads can increment ArrayList elements at the same time.

You can also use a

CopyOnWriteArrayList

if you need thread safety. It is a thread-safe version of the ArrayList class. It implements all the mutating operations by making a fresh copy of the ArrayList.

Java 61. Bài tập quản lý danh sách sinh viên trong Java sử dụng ArrayList
Java 61. Bài tập quản lý danh sách sinh viên trong Java sử dụng ArrayList

Add Items

The

ArrayList

class has many useful methods. For example, to add elements to the

ArrayList

, use the

add()

method:

Example


import java.util.ArrayList; public class Main { public static void main(String[] args) { ArrayList

cars = new ArrayList

(); cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("Mazda"); System.out.println(cars); } }


Java ArrayList

The

ArrayList

class is a resizable array, which can be found in the

java.util

package.

The difference between a built-in array and an

ArrayList

in Java, is that the size of an array cannot be modified (if you want to
add or remove elements to/from an array, you have to create a new one). While elements can be added and removed from an

ArrayList

whenever you want. The syntax is also slightly different:

Example

Create an

ArrayList

object called cars that will store strings:


import java.util.ArrayList; // import the ArrayList class ArrayList

cars = new ArrayList

(); // Create an ArrayList object


If you don’t know what a package is, read our Java Packages Tutorial.

ArrayLists in Java (Part 1)
ArrayLists in Java (Part 1)

Java


import


java.util.ArrayList;


public


class


GFG {


public


static


void


main(String[] args)


ArrayList

arr =



new


ArrayList


);


arr.add(


10


);


arr.add(


20


);


arr.add(


30


);


arr.add(


40


);


System.out.println(


"List: "


+ arr);


int


element = arr.get(


);


System.out.println(


"the element at index 2 is "


+ element);

Output

List: [10, 20, 30, 40]
the element at index 2 is 30

Example 2: Program to demonstrate the error

Removing elements from an ArrayList

This example shows:

  1. How to remove the element at a given index in an ArrayList | remove(int index)

  2. How to remove an element from an ArrayList | remove(Object o)

  3. How to remove all the elements from an ArrayList that exist in a given collection | removeAll()

  4. How to remove all the elements matching a given predicate | removeIf()

  5. How to clear an ArrayList | clear()


import java.util.ArrayList; import java.util.List; import java.util.function.Predicate; public class RemoveElementsFromArrayListExample { public static void main(String[] args) { List

programmingLanguages = new ArrayList<>(); programmingLanguages.add("C"); programmingLanguages.add("C++"); programmingLanguages.add("Java"); programmingLanguages.add("Kotlin"); programmingLanguages.add("Python"); programmingLanguages.add("Perl"); programmingLanguages.add("Ruby"); System.out.println("Initial List: " + programmingLanguages); // Remove the element at index `5` programmingLanguages.remove(5); System.out.println("After remove(5): " + programmingLanguages); // Remove the first occurrence of the given element from the ArrayList // (The remove() method returns false if the element does not exist in the ArrayList) boolean isRemoved = programmingLanguages.remove("Kotlin"); System.out.println("After remove(\"Kotlin\"): " + programmingLanguages); // Remove all the elements that exist in a given collection List

scriptingLanguages = new ArrayList<>(); scriptingLanguages.add("Python"); scriptingLanguages.add("Ruby"); scriptingLanguages.add("Perl"); programmingLanguages.removeAll(scriptingLanguages); System.out.println("After removeAll(scriptingLanguages): " + programmingLanguages); // Remove all the elements that satisfy the given predicate programmingLanguages.removeIf(new Predicate

() { @Override public boolean test(String s) { return s.startsWith("C"); } }); /* The above removeIf() call can also be written using lambda expression like this - programmingLanguages.removeIf(s -> s.startsWith("C")) */ System.out.println("After Removing all elements that start with \"C\": " + programmingLanguages); // Remove all elements from the ArrayList programmingLanguages.clear(); System.out.println("After clear(): " + programmingLanguages); } }




# Output Initial List: [C, C++, Java, Kotlin, Python, Perl, Ruby] After remove(5): [C, C++, Java, Kotlin, Python, Ruby] After remove("Kotlin"): [C, C++, Java, Python, Ruby] After removeAll(scriptingLanguages): [C, C++, Java] After Removing all elements that start with "C": [Java] After clear(): []

Array vs. ArrayList in Java Tutorial - What's The Difference?
Array vs. ArrayList in Java Tutorial – What’s The Difference?

Creating an ArrayList from another collection

This example shows:

  • How to create an ArrayList from another collection using the


    ArrayList(Collection c)

    constructor.

  • How to add all the elements from an existing collection to the new ArrayList using the


    addAll()

    method.


import java.util.ArrayList; import java.util.List; public class CreateArrayListFromCollectionExample { public static void main(String[] args) { List

firstFivePrimeNumbers = new ArrayList<>(); firstFivePrimeNumbers.add(2); firstFivePrimeNumbers.add(3); firstFivePrimeNumbers.add(5); firstFivePrimeNumbers.add(7); firstFivePrimeNumbers.add(11); // Creating an ArrayList from another collection List

firstTenPrimeNumbers = new ArrayList<>(firstFivePrimeNumbers); List

nextFivePrimeNumbers = new ArrayList<>(); nextFivePrimeNumbers.add(13); nextFivePrimeNumbers.add(17); nextFivePrimeNumbers.add(19); nextFivePrimeNumbers.add(23); nextFivePrimeNumbers.add(29); // Adding an entire collection to an ArrayList firstTenPrimeNumbers.addAll(nextFivePrimeNumbers); System.out.println(firstTenPrimeNumbers); } }




# Output [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

Các phương thức (method) của lớp ArrayList

Phương thức Mô tả
boolean add(Object o) Thêm phần tử được chỉ định vào cuối một danh sách.
void add(int index, Object element) Chèn một phần tử được chỉ định tại vị trí (index) được chỉ định vào danh sách. Ném IndexOutOfBoundsException nếu index này ở bên ngoài dãy (index < 0 hoặc index > size()).
boolean addAll(Collection c) Thêm tất cả các phần tử trong collection được chỉ định vào cuối của danh sách gọi phương thức, theo thứ tự chúng được trả về bởi bộ lặp iterator.
boolean addAll(int index, Collection c) Thêm tất cả các phần tử trong collection được chỉ định vào danh sách gọi phương thức, bắt đầu từ vị trí đã chỉ định. Ném NullPointerException nếu collection đã cho là null.
Object get(int index) Trả về phần tử tại index đã cho. Ném IndexOutOfBoundsException nếu index đã cho là ở bên ngoài dãy (index < 0 hoặc index >= size()).
int indexOf(Object o) Lấy vị trí (index) trong danh sách với sự xuất hiện đầu tiên của phần tử được chỉ định, hoặc -1 nếu danh sách không chứa phần tử này.
int lastIndexOf(Object o) Lấy vị trí (index) trong danh sách với sự xuất hiện cuối cùng của phần tử được chỉ định, hoặc -1 nếu danh sách không chứa phần tử này.
Object remove(int index) Gỡ bỏ phần tử tại index đã cho. Ném IndexOutOfBoundsException nếu index ở ngoài dãy (index < 0 hoặc index >= size()).
void retainAll(Collection c) Chỉ giữ lại các phần tử trong tập hợp này được chứa trong tập hợp đã chỉ định (những phần tử thuộc collection c).

Ném NullPointerException nếu collection đã cho là null.

void removeAll(Collection c) Loại bỏ tất cả các phần tử của bộ sưu tập này cũng có trong bộ sưu tập được chỉ định (những phần tử thuộc collection c). Sau khi thực thi, phương thức này trả về một tập hợp không chứa phần tử nào chung với tập hợp được chỉ định.

Ném NullPointerException nếu collection đã cho là null.

Object set(int index, Object element) Thay thế phần tử tại vị trí đã cho trong list này với phần tử đã xác định. Ném IndexOutOfBoundsException nếu index ở ngoài dãy (index < 0 hoặc index >= size()).
Object[] toArray() Chuyển một danh sách sang mảng và trả về một mảng chứa tất cả các phần tử trong danh sách này theo đúng thứ tự. Ném NullPointerException nếu mảng này là null.
Object[] toArray(Object[] a) Chuyển một danh sách sang mảng và trả về một mảng chứa tất cả các phần tử trong danh sách này theo đúng thứ tự. Kiểu runtime là của mảng trả về giống như mảng đã xác định.
Object clone() Tạo một bản sao của ArrayList.
void clear() Xóa tất cả các phần tử từ danh sách.
void trimToSize() Cắt dung lượng của thể hiện ArrayList này là kích thước danh sách hiện tại.
Java ArrayList 🧾
Java ArrayList 🧾

Java


import


java.util.ArrayList;


public


class


GFG {


public


static


void


main(String[] args)


ArrayList

arr =



new


ArrayList


);


arr.add(


10


);


arr.add(


20


);


arr.add(


30


);


arr.add(


40


);


int


element = arr.get(


);


System.out.println(


"the element at index 2 is "


+ element);

Output :

Exception in thread “main” java.lang.IndexOutOfBoundsException: Index: 5, Size: 4
at java.util.ArrayList.rangeCheck(ArrayList.java:657)
at java.util.ArrayList.get(ArrayList.java:433)
at GFG.main(GFG.java:22)

Feeling lost in the vast world of Backend Development? It’s time for a change! Join our Java Backend Development – Live Course and embark on an exciting journey to master backend development efficiently and on schedule. What We Offer:

  • Comprehensive Course
  • Expert Guidance for Efficient Learning
  • Hands-on Experience with Real-world Projects
  • Proven Track Record with 100,000+ Successful Geeks

Last Updated :
11 Jan, 2023

Like Article

Save Article

Share your thoughts in the comments

Please Login to comment…

Nội dung chính

  • Lớp ArrayList trong java
  • Hierarchy của lớp ArrayList trong java
  • Khởi tạo ArrayList trong java
  • Constructor của lớp ArrayList
  • Phương thức của lớp ArrayList
  • Các Ví dụ ArrayList trong Java

    • Khởi tạo một ArrayList
    • Hiển thị các phần tử có trong ArrayList
    • Các phương thức addAll(), removeAll(), retainAll() của lớp ArrayList
    • Truy cập phần tử của ArrayList
    • Cập nhật giá trị của phần tử Arraylist
    • Xóa phần tử ArrayList
    • Tìm kiếm một phần tử ArrayList
    • Chuyển ArrayList sang mảng (Array) trong Java
    • Tạo ArrayList có kiểu generic là String
    • Tạo ArrayList có kiểu generic là đối tượng do người dùng định nghĩa
  • So sánh ArrayList vs LinkedList

Java


import


java.util.ArrayList;


import


java.util.Iterator;


import


java.util.List;


public


class


GFG {


public


static


void


main(String[] args)


List

al =



new


ArrayList<>();


al.add(


10


);


al.add(


20


);


al.add(


30


);


al.add(


);


al.add(


);


System.out.println(al);


Iterator itr = al.iterator();


while


(itr.hasNext()) {


int


x = (Integer)itr.next();


if


(x <


10


itr.remove();


System.out.print(al);

Output

[10, 20, 30, 1, 2]
[10, 20, 30]

Feeling lost in the vast world of Backend Development? It’s time for a change! Join our Java Backend Development – Live Course and embark on an exciting journey to master backend development efficiently and on schedule. What We Offer:

  • Comprehensive Course
  • Expert Guidance for Efficient Learning
  • Hands-on Experience with Real-world Projects
  • Proven Track Record with 100,000+ Successful Geeks

Last Updated :
10 Jan, 2023

Like Article

Save Article

Share your thoughts in the comments

Please Login to comment…

Join two ArrayLists in Java

Given two ArrayLists in Java, the task is to join these ArrayLists.

Examples:

Input: ArrayList1: [Geeks, For, ForGeeks], ArrayList2: [GeeksForGeeks, A computer portal]
Output: ArrayList: [Geeks, For, ForGeeks, GeeksForGeeks, A computer portal]
Input: ArrayList1: [G, e, e, k, s], ArrayList2: [F, o, r, G, e, e, k, s]
Output: ArrayList: [G, e, e, k, s, F, o, r, G, e, e, k, s]

Approach:

ArrayLists can be joined in Java with the help of Collection.addAll() method. This method is called by the destination ArrayList and the other ArrayList is passed as the parameter to this method. This method appends the second ArrayList to the end of the first ArrayList.

Syntax:

ArrayList1.addAll(ArrayList2);

Below is the implementation of the above approach:


import


java.util.*;


public


class


GFG {


public


static


void


main(String args[])


ArrayList


list1 =


new


ArrayList

();


list1.add(


"Geeks"


);


list1.add(


"For"


);


list1.add(


"ForGeeks"


);


System.out.println(


"ArrayList 1: "


+ list1);


ArrayList


list2 =


new


ArrayList

();


list2.add(


"GeeksForGeeks"


);


list2.add(


"A computer portal"


);


System.out.println(


"ArrayList 2: "


+ list2);


list1.addAll(list2);


System.out.println(


"Joined ArrayLists: "


+ list1);

Feeling lost in the vast world of Backend Development? It’s time for a change! Join our Java Backend Development – Live Course and embark on an exciting journey to master backend development efficiently and on schedule. What We Offer:

  • Comprehensive Course
  • Expert Guidance for Efficient Learning
  • Hands-on Experience with Real-world Projects
  • Proven Track Record with 100,000+ Successful Geeks

Last Updated :
11 Dec, 2018

Like Article

Save Article

Share your thoughts in the comments

Please Login to comment…

ArrayList get(index) Method in Java with Examples

The get() method of ArrayList in Java is used to get the element of a specified index within the list.

Syntax:

get(index)

Parameter: Index of the elements to be returned. It is of data-type int.

Return Type: The element at the specified index in the given list.

Exception: It throws IndexOutOfBoundsException if the index is out of range (index=size())

Note: Time Complexity: ArrayList is one of the List implementations built a top an array. Hence, get(index) is always a constant time O(1) operation.

Example:

Java ArrayList | User Defined Objects in ArrayList with Example
Java ArrayList | User Defined Objects in ArrayList with Example

Other Types

Elements in an ArrayList are actually objects. In the examples above, we created elements
(objects) of type “String”. Remember that a String in Java is an object (not a primitive type). To use other types, such as int, you must specify an equivalent wrapper class:

Integer

. For other primitive types,
use:

Boolean

for boolean,

Character

for char,

Double

for double,
etc:

Example

Create an

ArrayList

to store numbers (add elements of type

Integer

):


import java.util.ArrayList; public class Main { public static void main(String[] args) { ArrayList

myNumbers = new ArrayList

(); myNumbers.add(10); myNumbers.add(15); myNumbers.add(20); myNumbers.add(25); for (int i : myNumbers) { System.out.println(i); } } }


Các phương thức khởi tạo (constructor) của lớp ArrayList

  • ArrayList(): khởi tạo một danh sách mảng trống.
  • ArrayList(Collection c): khởi tạo một danh sách mảng được khởi tạo với các phần tử của collection c.
  • ArrayList(int capacity): khởi tạo một danh sách mảng mà có sức chứa (compacity) ban đầu được chỉ định. Nếu không chỉ định, mặc định là 10. Mỗi lần thêm một phần tử vào danh sách, nếu vượt quá sức chứa cho phép thì danh sách sẽ tự động tăng thêm 50% kích thước hiện có.
#92 ArrayList in Java
#92 ArrayList in Java

Creating an ArrayList and adding new elements to it

This example shows:

  • How to create an ArrayList using the

    ArrayList()

    constructor.
  • Add new elements to an ArrayList using the

    add()

    method.


import java.util.ArrayList; import java.util.List; public class CreateArrayListExample { public static void main(String[] args) { // Creating an ArrayList of String List

animals = new ArrayList<>(); // Adding new elements to the ArrayList animals.add("Lion"); animals.add("Tiger"); animals.add("Cat"); animals.add("Dog"); System.out.println(animals); // Adding an element at a particular index in an ArrayList animals.add(2, "Elephant"); System.out.println(animals); } }


# Output [Lion, Tiger, Cat, Dog] [Lion, Tiger, Elephant, Cat, Dog]

So sánh ArrayList vs LinkedList

ArrayList và LinkedList đều là lớp triển khai của List Interface. Vậy khi nào chúng ta sẽ sử dụng ArrayList và khi nào chúng ta sẽ sử dụng LinkedList? Chúng ta sẽ sử dụng ArrayList khi ứng dụng của chúng ta cần truy xuất phần tử nhiều hơn cập nhật và xóa phần tử và chúng ta sẽ sử dụng LinkedList khi ứng dụng của chúng ta cần cập nhật và xóa phần tử nhiều hơn là truy cập phần tử.

Tìm hiểu thêm về Sự khác nhau giữa ArrayList và LinkedList

Java ArrayList

Bài 19: Phân biệt Array và ArrayList trong Java
Bài 19: Phân biệt Array và ArrayList trong Java

Loop Through an ArrayList

Loop through the elements of an

ArrayList

with a

for

loop, and use the

size()

method to specify how many times the loop should run:

Example


public class Main { public static void main(String[] args) { ArrayList

cars = new ArrayList

(); cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("Mazda"); for (int i = 0; i < cars.size(); i++) { System.out.println(cars.get(i)); } } }


You can also loop through an

ArrayList

with the for-each loop:

Example


public class Main { public static void main(String[] args) { ArrayList

cars = new ArrayList

(); cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("Mazda"); for (String i : cars) { System.out.println(i); } } }


Accessing elements from an ArrayList

This example shows:

  • How to check if an ArrayList is empty using the

    isEmpty()

    method.
  • How to find the size of an ArrayList using the

    size()

    method.
  • How to access the element at a particular index in an ArrayList using the

    get()

    method.
  • How to modify the element at a particular index in an ArrayList using the

    set()

    method.


import java.util.ArrayList; import java.util.List; public class AccessElementsFromArrayListExample { public static void main(String[] args) { List

topCompanies = new ArrayList<>(); // Check if an ArrayList is empty System.out.println("Is the topCompanies list empty? : " + topCompanies.isEmpty()); topCompanies.add("Google"); topCompanies.add("Apple"); topCompanies.add("Microsoft"); topCompanies.add("Amazon"); topCompanies.add("Facebook"); // Find the size of an ArrayList System.out.println("Here are the top " + topCompanies.size() + " companies in the world"); System.out.println(topCompanies); // Retrieve the element at a given index String bestCompany = topCompanies.get(0); String secondBestCompany = topCompanies.get(1); String lastCompany = topCompanies.get(topCompanies.size() - 1); System.out.println("Best Company: " + bestCompany); System.out.println("Second Best Company: " + secondBestCompany); System.out.println("Last Company in the list: " + lastCompany); // Modify the element at a given index topCompanies.set(4, "Walmart"); System.out.println("Modified top companies list: " + topCompanies); } }


# Output Is the topCompanies list empty? : true Here are the top 5 companies in the world [Google, Apple, Microsoft, Amazon, Facebook] Best Company: Google Second Best Company: Apple Last Company in the list: Facebook Modified top companies list: [Google, Apple, Microsoft, Amazon, Walmart]

Java Collections Framework-Part4 | ArrayList Concept | Hands-on
Java Collections Framework-Part4 | ArrayList Concept | Hands-on

Conclusion

That’s all folks. In this article, you learned what is an ArrayList, how to create an ArrayList, how to add, modify and remove elements from an ArrayList, how to iterate over an ArrayList, how to sort an ArrayList, and how to synchronize access to an ArrayList.

Thank you for reading. See you in the next post.

ArrayList is a part of collection framework and is present in java.util package. It provides us with dynamic arrays in Java. Though, it may be slower than standard arrays but can be helpful in programs where lots of manipulation in the array is needed. This class is found in java.util package. With the introduction and upgradations in java versions, newer methods are being available if we do see from Java8 perceptive lambda expressions and streams concepts were not available before it as it was introduced in java version8, so do we have more ways to operate over Arraylist to perform operations. Here we will be discussing a way to remove an element from an ArrayList.

While removing elements from ArrayList there can either we are operating to remove elements over indexes or via values been there in an ArrayList. We will be discussing both ways via interpreting through a clean java program.

Methods:

There are 3 ways to remove an element from ArrayList as listed which later on will be revealed as follows:

  1. Using remove() method by indexes(default)
  2. Using remove() method by values
  3. Using remove() method over iterators

Note: It is not recommended to use ArrayList.remove() when iterating over elements.

Method 1: Using remove() method by indexes

It is a default method as soon as we do use any method over data structure it is basically operating over indexes only so whenever we do use remove() method we are basically removing elements from indices from an ArrayList.

ArrayList class provides two overloaded remove() methods.

Let us figure out with the help of examples been provided below as follows:

Example:

Sorting an ArrayList

Sorting an ArrayList is a very common task that you will encounter in your programs. In this section, I’ll show you how to –

  • Sort an ArrayList using

    Collections.sort()

    method.
  • Sort an ArrayList using

    ArrayList.sort()

    method.
  • Sort an ArrayList of user defined objects with a custom comparator.
Sort an ArrayList using Collections.sort() method


import java.util.ArrayList; import java.util.Collections; import java.util.List; public class ArrayListCollectionsSortExample { public static void main(String[] args) { List

numbers = new ArrayList<>(); numbers.add(13); numbers.add(7); numbers.add(18); numbers.add(5); numbers.add(2); System.out.println("Before : " + numbers); // Sorting an ArrayList using Collections.sort() method Collections.sort(numbers); System.out.println("After : " + numbers); } }


# Output Before : [13, 7, 18, 5, 2] After : [2, 5, 7, 13, 18]

Sort an ArrayList using ArrayList.sort() method


import java.util.ArrayList; import java.util.Comparator; import java.util.List; public class ArrayListSortExample { public static void main(String[] args) { List

names = new ArrayList<>(); names.add("Lisa"); names.add("Jennifer"); names.add("Mark"); names.add("David"); System.out.println("Names : " + names); // Sort an ArrayList using its sort() method. You must pass a Comparator to the ArrayList.sort() method. names.sort(new Comparator

() { @Override public int compare(String name1, String name2) { return name1.compareTo(name2); } }); // The above `sort()` method call can also be written simply using lambda expression names.sort((name1, name2) -> name1.compareTo(name2)); // Following is an even more concise solution names.sort(Comparator.naturalOrder()); System.out.println("Sorted Names : " + names); } }



# Output Names : [Lisa, Jennifer, Mark, David] Sorted Names : [David, Jennifer, Lisa, Mark]

Sort an ArrayList of Objects using custom Comparator


import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; class Person { private String name; private Integer age; public Person(String name, Integer age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Override public String toString() { return "{" + "name='" + name + '\'' + ", age=" + age + '}'; } } public class ArrayListObjectSortExample { public static void main(String[] args) { List people = new ArrayList<>(); people.add(new Person("Sachin", 47)); people.add(new Person("Chris", 34)); people.add(new Person("Rajeev", 25)); people.add(new Person("David", 31)); System.out.println("Person List : " + people); // Sort People by their Age people.sort((person1, person2) -> { return person1.getAge() - person2.getAge(); }); // A more concise way of writing the above sorting function people.sort(Comparator.comparingInt(Person::getAge)); System.out.println("Sorted Person List by Age : " + people); // You can also sort using Collections.sort() method by passing the custom Comparator Collections.sort(people, Comparator.comparing(Person::getName)); System.out.println("Sorted Person List by Name : " + people); } }


# Output Person List : [{name='Sachin', age=47}, {name='Chris', age=34}, {name='Rajeev', age=25}, {name='David', age=31}] Sorted Person List by Age : [{name='Rajeev', age=25}, {name='David', age=31}, {name='Chris', age=34}, {name='Sachin', age=47}] Sorted Person List by Name : [{name='Chris', age=34}, {name='David', age=31}, {name='Rajeev', age=25}, {name='Sachin', age=47}]

Capgemini Interview | Java, Spring Boot, Microservices Question Answers
Capgemini Interview | Java, Spring Boot, Microservices Question Answers

ArrayList of ArrayList in Java Read Courses Improve Improve Improve Like Article Like Save Article Save Report issue Report We have discussed that an array of ArrayList is not possible without warning. A better idea is to use ArrayList of ArrayList. // Java code to demonstrate the concept of // array of ArrayList import java.util.*; public class Arraylist { public static void main(String[] args) { int n = 3; // Here aList is an ArrayList of ArrayLists ArrayList

> aList = new ArrayList

>(n); // Create n lists one by one and append to the // master list (ArrayList of ArrayList) ArrayList

a1 = new ArrayList

(); a1.add(1); a1.add(2); aList.add(a1); ArrayList

a2 = new ArrayList

(); a2.add(5); aList.add(a2); ArrayList

a3 = new ArrayList

(); a3.add(10); a3.add(20); a3.add(30); aList.add(a3); for (int i = 0; i < aList.size(); i++) { for (int j = 0; j < aList.get(i).size(); j++) { System.out.print(aList.get(i).get(j) + ” “); } System.out.println(); } } } Output: 1 2 5 10 20 30 Whether you’re preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we’ve already empowered, and we’re here to do the same for you. Don’t miss out – check it out now! Last Updated : 11 Dec, 2018 Like Article Save Article Previous Remove elements from a List that satisfy given predicate in Java Next Office Tools and Domain Specific Tools Share your thoughts in the comments Add Your Comment Please Login to comment…







By Pankaj

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Today we will learn how to create a Java array of ArrayList. We will also learn how to create an ArrayList of array elements.

Creating array of list in java is not complex. Below is a simple program showing java Array of ArrayList example.


import java.util.ArrayList; import java.util.List; public class JavaArrayOfArrayList { public static void main(String[] args) { List

l1 = new ArrayList<>(); l1.add("1"); l1.add("2"); List

l2 = new ArrayList<>(); l2.add("3"); l2.add("4"); l2.add("5"); List

[] arrayOfList = new List[2]; arrayOfList[0] = l1; arrayOfList[1] = l2; for (int i = 0; i < arrayOfList.length; i++) { List

l = arrayOfList[i]; System.out.println(l); } } }




Notice that we can’t use generics while creating the array because java doesn’t support generic array. So if we try to use below code, it will produce compile time error as “Cannot create a generic array of List

”.


List

[] arrayOfList = new List

[2];


We can also create an array whose elements are a list. Below is a simple example showing how to create a list of array elements in java.


import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class JavaArrayListOfStringArray { public static void main(String[] args) { // List of String arrays List

list = new ArrayList

(); String[] arr1 = { "a", "b", "c" }; String[] arr2 = { "1", "2", "3", "4" }; list.add(arr1); list.add(arr2); // printing list of String arrays in the ArrayList for (String[] strArr : list) { System.out.println(Arrays.toString(strArr)); } } }


If you are not sure about the type of objects in the array or you want to create an ArrayList of arrays that can hold multiple types, then you can create an ArrayList of an object array. Below is a simple example showing how to create ArrayList of object arrays in java.


import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class JavaArrayListOfObjectArray { public static void main(String[] args) { // list of Object arrays to hold different types of array List

list = new ArrayList

(); String[] arr1 = { "a", "b", "c" }; String[] arr2 = { "1", "2", "3", "4" }; JavaArrayListOfObjectArray aa = new JavaArrayListOfObjectArray(); JavaArrayListOfObjectArray.A[] arr3 = { aa.new A("AA"), aa.new A("BB") }; list.add(arr1); list.add(arr2); list.add(arr3); // list holds different types of Object arrays, let's print them for (Object[] objArr : list) { System.out.println(Arrays.toString(objArr)); // iterating over the array and doing operation based on it's type for (Object obj : objArr) { // using instanceof keyword to find the Object type in the array if (obj instanceof String) { // doSomethingForStringObject(); } else if (obj instanceof JavaArrayListOfObjectArray.A) { // doSomethingForAObject(); } } } } /** * A sample class to use in arraylist of arrays * * @author pankaj * */ public class A { private String name; public A(String n) { this.name = n; } public String getName() { return this.name; } @Override public String toString() { return "A.class::"+this.name; } } }


When we execute the above program, it produces the following output.


[a, b, c] [1, 2, 3, 4] [A.class::AA, A.class::BB]

That’s all for creating an Array of ArrayList and ArrayList of Array in Java.

You can checkout more core java examples from our GitHub Repository.

Reference: Java Arrays

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

On the space below, write down the code for declaring an integer array whare the values are 1,4,3,5and 6.

– Narzde Sam

Can someone help me out with simple coding with ARRAYS

– Eldridge Gee

how i can remove specific value on list of array string?

– Annisa Nurika

Thank you very much Pankaj this example is very clear and very helpful.

– Lithi P

Dear Pankaj, Very usefull your article. As I have told you the last time in my email to you. With this article, I have an idea developped below: – Create an arraylist: ArrayList dico = new ArrayList(); String[2] is a table of two String elements which represents ‘value of word attribute’ and ‘value of the word”s definition”. -But i don’t know how to populate my list ‘dico’. Please give me your solution. I wait your response. Thank in advance. Vu

– vu

Click below to sign up and get $200 of credit to try our products over 60 days!

Working on improving health and education, reducing inequality, and spurring economic growth? We’d like to help.

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

Java ArrayList Tutorial with Examples

JavaApril 20, 20184 mins read

ArrayList in Java is used to store dynamically sized collection of elements. Contrary to Arrays that are fixed in size, an ArrayList grows its size automatically when new elements are added to it.

ArrayList is part of Java’s collection framework and implements Java’s

List

interface.

Following are few key points to note about ArrayList in Java –

  • An ArrayList is a re-sizable array, also called a dynamic array. It grows its size to accommodate new elements and shrinks the size when the elements are removed.

  • ArrayList internally uses an array to store the elements. Just like arrays, It allows you to retrieve the elements by their index.

  • Java ArrayList allows duplicate and null values.

  • Java ArrayList is an ordered collection. It maintains the insertion order of the elements.

  • You cannot create an ArrayList of primitive types like


    int

    ,

    char

    etc. You need to use boxed types like

    Integer

    ,

    Character

    ,

    Boolean

    etc.

  • Java ArrayList is not synchronized. If multiple threads try to modify an ArrayList at the same time, then the final outcome will be non-deterministic. You must explicitly synchronize access to an ArrayList if multiple threads are gonna modify it.

Java


import


java.util.ArrayList;


import


java.util.List;


public


class


GFG {


public


static


void


main(String[] args)


List

al =



new


ArrayList<>();


al.add(


10


);


al.add(


20


);


al.add(


30


);


al.add(


);


al.add(


);


System.out.println(al);


al.remove(


);


al.remove(


);


System.out.println(al);

Output

[10, 20, 30, 1, 2]
[10, 1, 2]

Now we have seen removing elements in an ArrayList via indexes above, now let us see that the passed parameter is considered an index. How to remove elements by value.

Method 2: Using remove() method by values

Example:

Prefer Arrays Over Lists. Seriously...
Prefer Arrays Over Lists. Seriously…

Constructor trong ArrayList

Để tạo một ArrayList, chúng ta cần tạo một đối tượng của lớp ArrayList. Lớp ArrayList bao gồm các hàm tạo quan trọng cho phép có thể tạo danh sách mảng. Sau đây là các hàm tạo có sẵn trong lớp này:

  1. ArrayList(): Hàm tạo này được sử dụng để xây dựng một danh sách mảng trống. Nếu chúng ta muốn tạo một ArrayList trống với tên arr, thì nó có thể được tạo như sau:

ArrayList arr = new ArrayList();

  1. ArrayList(Collection c): Hàm tạo này được sử dụng để xây dựng một danh sách mảng được khởi tạo với các phần tử từ collection c. Giả sử, chúng ta muốn tạo một mảng ArrayList chứa các phần tử có trong tập hợp c, sau đó, nó có thể được tạo như sau:

ArrayList arr = new ArrayList(c);

  1. ArrayList(int capacity): Hàm tạo này được sử dụng để xây dựng một danh sách mảng với size ban đầu được chỉ định. Giả sử chúng ta muốn tạo một ArrayList với kích thước ban đầu là N, thì nó có thể được tạo như sau:

ArrayList arr = new ArrayList(N);

Iterating over an ArrayList

The following example shows how to iterate over an ArrayList using

  1. Java 8

    forEach

    and lambda expression.

  2. iterator()

    .

  3. iterator()

    and Java 8 forEachRemaining() method.

  4. listIterator()

    .
  5. Simple for-each loop.
  6. for loop with index.


import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator; public class IterateOverArrayListExample { public static void main(String[] args) { List

tvShows = new ArrayList<>(); tvShows.add("Breaking Bad"); tvShows.add("Game Of Thrones"); tvShows.add("Friends"); tvShows.add("Prison break"); System.out.println("=== Iterate using Java 8 forEach and lambda ==="); tvShows.forEach(tvShow -> { System.out.println(tvShow); }); System.out.println("\n=== Iterate using an iterator() ==="); Iterator

tvShowIterator = tvShows.iterator(); while (tvShowIterator.hasNext()) { String tvShow = tvShowIterator.next(); System.out.println(tvShow); } System.out.println("\n=== Iterate using an iterator() and Java 8 forEachRemaining() method ==="); tvShowIterator = tvShows.iterator(); tvShowIterator.forEachRemaining(tvShow -> { System.out.println(tvShow); }); System.out.println("\n=== Iterate using a listIterator() to traverse in both directions ==="); // Here, we start from the end of the list and traverse backwards. ListIterator

tvShowListIterator = tvShows.listIterator(tvShows.size()); while (tvShowListIterator.hasPrevious()) { String tvShow = tvShowListIterator.previous(); System.out.println(tvShow); } System.out.println("\n=== Iterate using simple for-each loop ==="); for(String tvShow: tvShows) { System.out.println(tvShow); } System.out.println("\n=== Iterate using for loop with index ==="); for(int i = 0; i < tvShows.size(); i++) { System.out.println(tvShows.get(i)); } } }




# Output === Iterate using Java 8 forEach and lambda === Breaking Bad Game Of Thrones Friends Prison break === Iterate using an iterator() === Breaking Bad Game Of Thrones Friends Prison break === Iterate using an iterator() and Java 8 forEachRemaining() method === Breaking Bad Game Of Thrones Friends Prison break === Iterate using a listIterator() to traverse in both directions === Prison break Friends Game Of Thrones Breaking Bad === Iterate using simple for-each loop === Breaking Bad Game Of Thrones Friends Prison break === Iterate using for loop with index === Breaking Bad Game Of Thrones Friends Prison break

The

iterator()

and

listIterator()

methods are useful when you need to modify the ArrayList while traversing.

Consider the following example, where we remove elements from the ArrayList using

iterator.remove()

method while traversing through it –


import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ArrayListIteratorRemoveExample { public static void main(String[] args) { List

numbers = new ArrayList<>(); numbers.add(13); numbers.add(18); numbers.add(25); numbers.add(40); Iterator

numbersIterator = numbers.iterator(); while (numbersIterator.hasNext()) { Integer num = numbersIterator.next(); if(num % 2 != 0) { numbersIterator.remove(); } } System.out.println(numbers); } }



# Output [18, 40]

#91 Collection API in Java
#91 Collection API in Java

Các Ví dụ ArrayList trong Java

Khởi tạo một ArrayList

Để khai báo một ArrayList, chúng ta cần phải import gói thư viện java.util.ArrayList của Java. Cú pháp import như sau:

// import gói thư viện java.util.ArrayList import java.util.ArrayList; public class KhoiTaoArrayList { public static void main(String[] args) { // khai báo 1 ArrayList có tên là listString // có kiểu là String ArrayList

listString = new ArrayList

(); } }

Ngoài ra, nếu chúng ta đã biết trước số lượng phần tử thì chúng ta có thể khai báo kèm với số lượng phần tử của nó. Ví dụ dưới đây sẽ khai báo một ArrayList có kiểu String và có 20 phần tử:

// import gói thư viện java.util.ArrayList import java.util.ArrayList; public class KhoiTaoArrayList { public static void main(String[] args) { // khai báo 1 ArrayList có tên là listString // có kiểu là String ArrayList

listString = new ArrayList

(20); } }

Hiển thị các phần tử có trong ArrayList

Để hiển thị các phần tử có trong ArrayList, chúng ta có các cách như sau:

Hiển thị theo tên của ArrayList.

package vn.viettuts.arraylist; import java.util.ArrayList; public class DuyetArrayList1 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // hiển thị các phần tử của list System.out.println(“Các phần tử có trong list là: “); System.out.println(list); } }

Kết quả:

Duyệt các phần tử của ArrayList – sử dụng vòng lặp for

package vn.viettuts.arraylist; import java.util.ArrayList; public class DuyetArrayList2 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // sử dụng vòng lặp for – hiển thị các phần tử của list System.out.println(“Các phần tử có trong list là: “); for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } } }

Kết quả:

Duyệt các phần tử của ArrayList – sử dụng vòng lặp for cải tiến

package vn.viettuts.arraylist; import java.util.ArrayList; public class DuyetArrayList3 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // sử dụng vòng lặp for cải tiến – hiển thị các phần tử của list System.out.println(“Các phần tử có trong list là: “); for (String str : list) { System.out.println(str); } } }

Kết quả:

Duyệt các phần tử của ArrayList – sử dụng Iterator.

Để sử dụng được Iterator chúng ta cần phải import gói thư viện java.util.Iterator của Java.

package vn.viettuts.arraylist; import java.util.ArrayList; import java.util.Iterator; public class DuyetArrayList4 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // sử dụng Iterator – hiển thị các phần tử của list Iterator

iterator = list.iterator(); System.out.println(“Các phần tử có trong list là: “); while (iterator.hasNext()) { System.out.println((String) iterator.next()); } } }


Kết quả:

Duyệt các phần tử của ArrayList – sử dụng ListIterator.

Vì ArrayList là một lớp triển khai của List Interface nên nó cũng có thể sử dụng ListIterator để duyệt qua các phần tử của nó. Để sử dụng được ListIterator chúng ta cần phải import gói thư viện java.util.ListIterator của Java.

package vn.viettuts.arraylist; import java.util.ArrayList; import java.util.ListIterator; public class DuyetArrayList5 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // sử dụng ListIterator – hiển thị các phần tử của list ListIterator

iterator = list.listIterator(); System.out.println(“Các phần tử có trong list là: “); while (iterator.hasNext()) { System.out.println((String) iterator.next()); } } }


Kết quả:

Các phương thức addAll(), removeAll(), retainAll() của lớp ArrayList

Ví dụ sau minh họa cách sử dụng các phương thức addAll(), removeAll(), retainAll() của lớp ArrayList trong Java:

package vn.viettuts.arraylist; import java.util.ArrayList; public class PhuongThucArrayList1 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // Add objects to list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); System.out.println(“ví dụ sử dụng phương thức addAll()”); System.out.println(“———————————–“); // thêm các phần tử của list vào listA ArrayList

listA = new ArrayList

(); listA.addAll(list); System.out.print(“listA:”); showList(listA); System.out.println(“\nví dụ sử dụng phương thức retainAll()”); System.out.println(“———————————–“); // khởi tạo listB ArrayList

listB = new ArrayList

(); listB.add(“Java”); // xóa những phần tử không thuộc listB khỏi listA listA.retainAll(listB); System.out.print(“listA:”); showList(listA); System.out.println(“\nví dụ sử dụng phương thức removeAll()”); System.out.println(“———————————–“); // xóa những phần tử thuộc listB khỏi list list.removeAll(listB); System.out.print(“list:”); showList(list); } public static void showList(ArrayList

list) { // Show list through for-each for (String obj : list) { System.out.print(“\t” + obj + “, “); } System.out.println(); } }






Kết quả:

ví dụ sử dụng phương thức addAll() ———————————– listA: Java, C++, PHP, Java, ví dụ sử dụng phương thức retainAll() ———————————– listA: Java, Java, ví dụ sử dụng phương thức removeAll() ———————————– list: C++, PHP,

Truy cập phần tử của ArrayList

Java cung cấp cho chúng ta phương thức get() để truy cập đến 1 phần tử bất kỳ trong ArrayList thông qua chỉ số của phần tử đó. Chỉ số của ArrayList trong Java bắt đầu từ 0.

package vn.viettuts.arraylist; import java.util.ArrayList; public class TruyCapArrayList1 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // truy cập phần tử có chỉ số 3 của list System.out.println(list.get(3)); } }

Kết quả:

Java

Cập nhật giá trị của phần tử Arraylist

Để cập nhật giá trị của phần tử trong ArrayList, Java cung cấp cho chúng ta phương thức set(index, element), trong đó index là chỉ số của phần tử cần cập nhật và element là phần tử mới để thay thế.

package vn.viettuts.arraylist; import java.util.ArrayList; public class CapNhatArrayList1 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); System.out.println(“list trước khi cập nhật: “); System.out.println(list); // cập nhật giá trị cho phần tử có chỉ số là 3 (Java) list.set(3, “Python”); System.out.println(“list trước khi cập nhật: “); System.out.println(list); } }

Kết quả:

list trước khi cập nhật: [Java, C++, PHP, Java] list trước khi cập nhật: [Java, C++, PHP, Python]

Xóa phần tử ArrayList

Để xóa phần tử trong ArrayList, Java cung cấp cho chúng ta 2 phương thức có sẵn đó là phương thức clear() và phương thức remove().

Phương thức clear()

Phương thức clear() sẽ xóa tất cả các phần tử có trong ArrayList. Sau đây là ví dụ minh họa phương thức này.

package vn.viettuts.arraylist; import java.util.ArrayList; public class XoaArrayList1 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Python”); System.out.println(“Số phần tử của list ban đầu : ” + list); System.out.println(“Các phần tử của list ban đầu: ” + list.size()); // clear list list.clear(); System.out.println(“\nSố phần tử của list sau khi clear: ” + list); System.out.println(“Các phần tử của list sau khi clear: ” + list.size()); } }

Kết quả:

Số phần tử của list ban đầu : [Java, C++, PHP, Python] Các phần tử của list ban đầu: 4 Số phần tử của list sau khi clear: [] Các phần tử của list sau khi clear: 0

Phương thức remove()

Phương thức remove() sẽ xóa phần tử ra khỏi ArrayList theo 2 cách đó là xóa dựa vào chỉ số của phần tử và xóa trực tiếp phần tử đó (không cần biết đến chỉ số của nó). Ví dụ dưới đây sẽ minh họa 2 cách xóa này:

package vn.viettuts.arraylist; import java.util.ArrayList; public class XoaArrayList1 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Python”); System.out.println(“Số phần tử của list ban đầu : ” + list); System.out.println(“Các phần tử của list ban đầu: ” + list.size()); // remove phần tử có chỉ số index = 1 khỏi list list.remove(1); System.out.println(“\nSố phần tử của list sau khi remove phan tu co index = 1: ” + list); System.out.println(“Các phần tử của list sau khi remove phan tu co index = 1: ” + list.size()); // remove phần tử có chỉ số index = 1 khỏi list list.remove(“PHP”); System.out.println(“\nSố phần tử của list sau khi remove phan tu \”PHP\”: ” + list); System.out.println(“Các phần tử của list sau khi remove phan tu \”PHP\”: ” + list.size()); } }

Kết quả:

Số phần tử của list ban đầu : [Java, C++, PHP, Python] Các phần tử của list ban đầu: 4 Số phần tử của list sau khi remove phan tu co index = 1: [Java, PHP, Python] Các phần tử của list sau khi remove phan tu co index = 1: 3 Số phần tử của list sau khi remove phan tu “PHP”: [Java, Python] Các phần tử của list sau khi remove phan tu “PHP”: 2

Tìm kiếm một phần tử ArrayList

Để tìm kiếm một phần tử trong ArrayList thì chúng ta có 3 phương pháp tìm kiếm như sau:

Tìm kiếm trực tiếp phần tử.

Để tìm kiếm trực tiếp phần tử, chúng ta sẽ sử dụng phương thức contains() . Kết quả trả về là true nếu tìm thấy, ngược lại trả về false.

package vn.viettuts.arraylist; import java.util.ArrayList; public class TimKiemArrayList1 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Python”); // kiểm tra xem PHP có tồn tại trong list hay không? System.out.println(list.contains(“PHP”)); // kiểm tra xem ANDROID có tồn tại trong list hay không? System.out.println(list.contains(“ANDROID”)); } }

Kết quả:

true false

Tìm kiếm vị trí xuất hiện đầu tiên của 1 phần tử trong ArrayList.

Để tìm kiếm vị trí xuất hiện đầu tiên của 1 phần tử trong ArrayList, chúng ta sẽ sừ dụng phương thức indexOf(). Kết quả của phương thức này sẽ trả về chỉ số xuất hiện đầu tiên của phần tử đó trong ArrayList, ngược lại nếu không tìm thấy trả về -1.

package vn.viettuts.arraylist; import java.util.ArrayList; public class TimKiemArrayList2 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Python”); // kiểm tra xem Java có tồn tại trong list hay không? System.out.println(list.indexOf(“Java”)); // kiểm tra xem ANDROID có tồn tại trong list hay không? System.out.println(list.indexOf(“ANDROID”)); } }

Kết quả:

0 -1

Tìm kiếm vị trí xuất hiện cuối cùng của 1 phần tử trong List.

Để tìm kiếm vị trí xuất hiện cuối cùng của 1 phần tử trong ArrayList, chúng ta sẽ sừ dụng phương thức lastIndexOf(). Kết quả của phương thức này sẽ trả về chỉ số xuất hiện cuối cùng của phần tử đó trong ArrayList, ngược lại nếu không tìm thấy trả về -1.

package vn.viettuts.arraylist; import java.util.ArrayList; public class TimKiemArrayList3 { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // kiểm tra xem Java có tồn tại trong list hay không? System.out.println(list.lastIndexOf(“Java”)); // kiểm tra xem ANDROID có tồn tại trong list hay không? System.out.println(list.lastIndexOf(“ANDROID”)); } }

Kết quả:

3 -1

Chuyển ArrayList sang mảng (Array) trong Java

Phương thức toArray() trong Java được dùng để chuyển đổi một ArrayList sang mảng tương ứng. Sau đây là ví dụ minh họa phương thức này:

package vn.viettuts.arraylist; import java.util.ArrayList; public class ConvertToArray { public static void main(String[] args) { // khai báo 1 ArrayList có tên là list // có kiểu là String ArrayList

list = new ArrayList

(); // thêm các phần tử vào list list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // sử dụng phương thức toArray() chuyển list thành mảng // kết quả của phương thức này sẽ trả về mảng arr Object[] arr = list.toArray(); // hiển thị các phần tử có trong mảng arr for (int i = 0; i < arr.length; i++) { System.out.println(“Phần tử tại vị trí ” + i + ” ” + “trong arr là ” + arr[i]); } } }

Kết quả:

Phần tử tại vị trí 0 trong arr là Java Phần tử tại vị trí 1 trong arr là C++ Phần tử tại vị trí 2 trong arr là PHP Phần tử tại vị trí 3 trong arr là Java

Tạo ArrayList có kiểu generic là String

File: ArrayListExample1.java

import java.util.ArrayList; import java.util.Iterator; public class ArrayListExample1 { public static void main(String args[]) { // Creating arraylist ArrayList

list = new ArrayList

(); // Add objects to arraylist list.add(“Java”); list.add(“C++”); list.add(“PHP”); list.add(“Java”); // Show list through Iterator Iterator

itr = list.iterator(); while (itr.hasNext()) { System.out.print(itr.next() + “, “); } // Show list through for-each System.out.println(); for (String obj : list) { System.out.print(obj + “, “); } // Show list through index System.out.println(); int size = list.size(); for (int i = 0; i < size; i++) { System.out.print(list.get(i) + “, “); } } }


Tạo ArrayList có kiểu generic là đối tượng do người dùng định nghĩa

File: ArrayListExample2.java

import java.util.ArrayList; class Student { private String name; private int age; public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return “Student@[name=” + name + “, age=” + age + “]”; } } public class ArrayListExample2 { public static void main(String[] args) { // Create listStudent ArrayList

listStudent = new ArrayList

(); // Create students Student student1 = new Student(“Bac”, 17); Student student2 = new Student(“Nam”, 20); Student student3 = new Student(“Trung”, 19); // Add objects to listStudent listStudent.add(student1); listStudent.add(student2); listStudent.add(student3); // Show listStudent for (Student student : listStudent) { System.out.println(student.toString()); } } }

Output:

Student@[name=Bac, age=17] Student@[name=Nam, age=20] Student@[name=Trung, age=19]

Java


import


java.util.ArrayList;


import


java.util.List;


public


class


GFG {


public


static


void


main(String[] args)


List

al =



new


ArrayList<>();


al.add(


10


);


al.add(


20


);


al.add(


30


);


al.add(


);


al.add(


);


System.out.println(al);


al.remove(Integer.valueOf(


));


al.remove(Integer.valueOf(


));


System.out.println(al);

Output :

[10, 20, 30,1 ,2]
[10, 20, 30]

Note: It is not recommended to use ArrayList.remove() when iterating over elements.

Also new Integer( int_value) has been deprecated since Java 9, so it is better idea to use Integer.valueOf(int_value) to convert a primitive integer to Integer Object.

Method 3: Using Iterator.remove() method

This may lead to ConcurrentModificationException When iterating over elements, it is recommended to use Iterator.remove() method.

Example:

Java Collections Framework | Full Course ✅
Java Collections Framework | Full Course ✅

Searching for elements in an ArrayList

The example below shows how to:

  • Check if an ArrayList contains a given element | contains()

  • Find the index of the first occurrence of an element in an ArrayList | indexOf()

  • Find the index of the last occurrence of an element in an ArrayList | lastIndexOf()


import java.util.ArrayList; import java.util.List; public class SearchElementsInArrayListExample { public static void main(String[] args) { List

names = new ArrayList<>(); names.add("John"); names.add("Alice"); names.add("Bob"); names.add("Steve"); names.add("John"); names.add("Steve"); names.add("Maria"); // Check if an ArrayList contains a given element System.out.println("Does names array contain \"Bob\"? : " + names.contains("Bob")); // Find the index of the first occurrence of an element in an ArrayList System.out.println("indexOf \"Steve\": " + names.indexOf("Steve")); System.out.println("indexOf \"Mark\": " + names.indexOf("Mark")); // Find the index of the last occurrence of an element in an ArrayList System.out.println("lastIndexOf \"John\" : " + names.lastIndexOf("John")); System.out.println("lastIndexOf \"Bill\" : " + names.lastIndexOf("Bill")); } }


# Output Does names array contain "Bob"? : true indexOf "Steve": 3 indexOf "Mark": -1 lastIndexOf "John" : 4 lastIndexOf "Bill" : -1

Giới thiệu

Lớp ArrayList trong java được sử dụng như một mảng động để lưu trữ các phần tử. Nó kế thừa lớp AbstractList và impliments giao tiếp List.

Các mảng Java chuẩn là có độ dài cố định. Sau khi các mảng được tạo, chúng không thể tăng hoặc giảm kích cỡ, nghĩa là bạn phải có bao nhiêu phần tử mà một mảng sẽ giữ.

ArrayList được tạo với một kích cỡ ban đầu. Khi kích cỡ này bị vượt, collection tự động được tăng. Khi các đối tượng bị gỡ bỏ, ArrayList có thể bị giảm kích cỡ.

Những điểm cần ghi nhớ về lớp ArrayList:

  • Có thể chứa các phần tử trùng lặp.
  • Duy trì thứ tự của phần tử được thêm vào.
  • Không đồng bộ (non-synchronized).
  • Cho phép truy cập ngẫu nhiên, tốc độ truy xuất (get) phần tử nhanh vì nó lưu dữ liệu theo chỉ mục.
  • Thao tác thêm/ xóa (add/ remove) phần tử chậm vì cần nhiều sự dịch chuyển nếu bất kỳ phần tử nào thêm/ xoá khỏi danh sách.

Hierarchy của lớp ArrayList trong java

Lớp java.util.ArrayList được định nghĩa như sau:

public class ArrayList

extends AbstractList

implements List

, RandomAccess, Cloneable, java.io.Serializable


Array of Objects Java Tutorial #73
Array of Objects Java Tutorial #73

ArrayList of user defined objects

Since ArrayList supports generics, you can create an ArrayList of any type. It can be of simple types like

Integer

,

String

,

Double

or complex types like an ArrayList of ArrayLists, or an ArrayList of HashMaps or an ArrayList of any user defined objects.

In the following example, you’ll learn how to create an ArrayList of user defined objects.


import java.util.ArrayList; import java.util.List; class User { private String name; private int age; public User(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } public class ArrayListUserDefinedObjectExample { public static void main(String[] args) { List

users = new ArrayList<>(); users.add(new User("Rajeev", 25)); users.add(new User("John", 34)); users.add(new User("Steve", 29)); users.forEach(user -> { System.out.println("Name : " + user.getName() + ", Age : " + user.getAge()); }); } }


# Output Name : Rajeev, Age : 25 Name : John, Age : 34 Name : Steve, Age : 29

Ví dụ minh họa

Ví dụ sử dụng ArrayList với kiểu dữ liệu cơ bản (Wrapper)

package com.gpcoder.collection.arraylist; import java.util.ArrayList; import java.util.List; public class ArrayListExample { public static final int NUM_OF_ELEMENT = 5; public static void main(String[] args) { // Create list with no parameter List

list1 = new ArrayList<>(); for (int i = 1; i <= NUM_OF_ELEMENT; i++) { // Add element to list list1.add(“0” + i); } System.out.print(“Init list1 = “); printData(list1); // addAll() List

list2 = new ArrayList<>(); list2.addAll(list1); list2.add(“0” + 3); System.out.print(“After list1.addAll(03): list2 = “); printData(list2); // IndexOf() System.out.println(“list2.indexOf(03) = ” + list2.indexOf(“03”)); System.out.println(“list2.indexOf(06) = ” + list2.indexOf(“06”)); // lastIndexOf() System.out.println(“list2.lastIndexOf(03) = ” + list2.lastIndexOf(“03”)); // Remove list2.remove(“01”); System.out.print(“After list2.remove(01): list2 = “); printData(list2); // retainAll() List

list4 = new ArrayList<>(list1); ArrayList

list3 = new ArrayList

(); list3.add(“0” + 3); list3.add(“0” + 2); System.out.print(“Init list3 = “); printData(list3); list4.retainAll(list3); System.out.print(“After list1.retainAll(list3): list4 = “); printData(list4); // removeAll() List

list5 = new ArrayList<>(list1); list5.removeAll(list3); System.out.print(“After list1.removeAll(list3): list5 = “); printData(list5); } public static void printData(List

list) { // Show list through for-each for (String item : list) { System.out.print(item + ” “); } System.out.println(); } }






Kết quả thực thi chương trình trên:

Init list1 = 01 02 03 04 05 After list1.addAll(03): list2 = 01 02 03 04 05 03 list2.indexOf(03) = 2 list2.indexOf(06) = -1 list2.lastIndexOf(03) = 5 After list2.remove(01): list2 = 02 03 04 05 03 Init list3 = 03 02 After list1.retainAll(list3): list4 = 02 03 After list1.removeAll(list3): list5 = 01 04 05

Ví dụ sử dụng ArrayList với kiểu do người dùng tự định nghĩa (Object)

package com.gpcoder.collection.arraylist; import java.util.ArrayList; import java.util.List; class Student { private int id; private String name; public Student(int id, String name) { this.id = id; this.name = name; } @Override public String toString() { return “Student [id=” + id + “, name=” + name + “]”; } } public class ArrayListExample { public static final int NUM_OF_ELEMENT = 5; public static void main(String[] args) { // Create list with compacity = 3 List

students = new ArrayList<>(3); for (int i = 1; i <= NUM_OF_ELEMENT; i++) { // Add element to list Student student = new Student(i, “myname” + i); students.add(student); } // Show list student for (Student student : students) { System.out.println(student); } } }

Kết quả thực thi chương trình trên:

Student [id=1, name=myname1] Student [id=2, name=myname2] Student [id=3, name=myname3] Student [id=4, name=myname4] Student [id=5, name=myname5]

public class ArrayList

extends AbstractList

implements List

, RandomAccess, Cloneable, Serializable


The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O(n) time. All of the other operations run in linear time (roughly speaking). The constant factor is low compared to that for the LinkedList implementation.

Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.

An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.

Note that this implementation is not synchronized.
If multiple threads access an ArrayList instance concurrently,
and at least one of the threads modifies the list structurally, it
must be synchronized externally. (A structural modification is
any operation that adds or deletes one or more elements, or explicitly
resizes the backing array; merely setting the value of an element is not
a structural modification.) This is typically accomplished by
synchronizing on some object that naturally encapsulates the list.
If no such object exists, the list should be “wrapped” using the

Collections.synchronizedList

method. This is best done at creation time, to prevent accidental
unsynchronized access to the list:

List list = Collections.synchronizedList(new ArrayList(…));

The iterators returned by this class’s

iterator

and

listIterator

methods are fail-fast:
if the list is structurally modified at any time after the iterator is
created, in any way except through the iterator’s own

remove

or

add

methods, the iterator will throw a

ConcurrentModificationException

. Thus, in the face of
concurrent modification, the iterator fails quickly and cleanly, rather
than risking arbitrary, non-deterministic behavior at an undetermined
time in the future.

Note that the fail-fast behavior of an iterator cannot be guaranteed
as it is, generally speaking, impossible to make any hard guarantees in the
presence of unsynchronized concurrent modification. Fail-fast iterators
throw

ConcurrentModificationException

on a best-effort basis.
Therefore, it would be wrong to write a program that depended on this
exception for its correctness: the fail-fast behavior of iterators
should be used only to detect bugs.

This class is a member of the Java Collections Framework.


Collection,


List,


LinkedList,


Vector, Serialized Form


modCount

Constructor and Description

Constructs an empty list with an initial capacity of ten.

Constructs a list containing the elements of the specified collection, in the order they are returned by the collection’s iterator.

Constructs an empty list with the specified initial capacity.

Modifier and Type Method and Description

Appends the specified element to the end of this list.

Inserts the specified element at the specified position in this list.

Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection’s Iterator.

Inserts all of the elements in the specified collection into this list, starting at the specified position.

Removes all of the elements from this list.

Returns a shallow copy of this ArrayList instance.

Returns true if this list contains the specified element.

Increases the capacity of this ArrayList instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.

Performs the given action for each element of the

Returns the element at the specified position in this list.

Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.

Returns true if this list contains no elements.

Returns an iterator over the elements in this list in proper sequence.

Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.

Returns a list iterator over the elements in this list (in proper sequence).

Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.

Removes the element at the specified position in this list.

Removes the first occurrence of the specified element from this list, if it is present.

Removes from this list all of its elements that are contained in the specified collection.

Removes all of the elements of this collection that satisfy the given predicate.

Removes from this list all of the elements whose index is between

Replaces each element of this list with the result of applying the operator to that element.

Retains only the elements in this list that are contained in the specified collection.

Replaces the element at the specified position in this list with the specified element.

Returns the number of elements in this list.

Sorts this list according to the order induced by the specified

Creates a late-binding and fail-fast

Returns a view of the portion of this list between the specified

Returns an array containing all of the elements in this list in proper sequence (from first to last element).

Returns an array containing all of the elements in this list in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array.

Trims the capacity of this ArrayList instance to be the list’s current size.


equals, hashCode


containsAll, toString


finalize, getClass, notify, notifyAll, wait, wait, wait


containsAll, equals, hashCode


parallelStream, stream

public ArrayList(int initialCapacity)


initialCapacity- the initial capacity of the list


IllegalArgumentException- if the specified initial capacity is negative

public ArrayList()

public ArrayList(Collection

c)


c- the collection whose elements are to be placed into this list


NullPointerException- if the specified collection is null

public void trimToSize()

public void ensureCapacity(int minCapacity)


minCapacity- the desired minimum capacity

public int size()


sizein interface


Collection


sizein interface


List


sizein class


AbstractCollection

public boolean isEmpty()


isEmptyin interface


Collection


isEmptyin interface


List


isEmptyin class


AbstractCollection

public boolean contains(Object o)


containsin interface


Collection


containsin interface


List


containsin class


AbstractCollection


o- element whose presence in this list is to be tested

public int indexOf(Object o)

public int lastIndexOf(Object o)


lastIndexOfin interface


List


lastIndexOfin class


AbstractList


o- element to search for

public Object clone()

public Object[] toArray()

The returned array will be “safe” in that no references to it are maintained by this list. (In other words, this method must allocate a new array). The caller is thus free to modify the returned array.

This method acts as bridge between array-based and collection-based APIs.


toArrayin interface


Collection


toArrayin interface


List


toArrayin class


AbstractCollection


Arrays.asList(Object[])

public

T[] toArray(T[] a)

If the list fits in the specified array with room to spare (i.e., the array has more elements than the list), the element in the array immediately following the end of the collection is set to null. (This is useful in determining the length of the list only if the caller knows that the list does not contain any null elements.)


toArrayin interface


Collection


toArrayin interface


List


toArrayin class


AbstractCollection


T- the runtime type of the array to contain the collection


a- the array into which the elements of the list are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.


ArrayStoreException- if the runtime type of the specified array is not a supertype of the runtime type of every element in this list


NullPointerException- if the specified array is null

public E get(int index)


getin interface


List


getin class


AbstractList


index- index of the element to return


IndexOutOfBoundsException- if the index is out of range (index < 0 || index >= size())

public E set(int index, E element)


setin interface


List


setin class


AbstractList


index- index of the element to replace


element- element to be stored at the specified position


IndexOutOfBoundsException- if the index is out of range (index < 0 || index >= size())

public boolean add(E e)


addin interface


Collection


addin interface


List


addin class


AbstractList


e- element to be appended to this list


Collection.add(E))

public void add(int index, E element)


addin interface


List


addin class


AbstractList


index- index at which the specified element is to be inserted


element- element to be inserted


IndexOutOfBoundsException- if the index is out of range (index < 0 || index > size())

public E remove(int index)


removein interface


List


removein class


AbstractList


index- the index of the element to be removed


IndexOutOfBoundsException- if the index is out of range (index < 0 || index >= size())

public boolean remove(Object o)


removein interface


Collection


removein interface


List


removein class


AbstractCollection


o- element to be removed from this list, if present

public void clear()


clearin interface


Collection


clearin interface


List


clearin class


AbstractList

public boolean addAll(Collection

c)


addAllin interface


Collection


addAllin interface


List


addAllin class


AbstractCollection


c- collection containing elements to be added to this list


NullPointerException- if the specified collection is null


AbstractCollection.add(Object)

public boolean addAll(int index, Collection

c)


addAllin interface


List


addAllin class


AbstractList


index- index at which to insert the first element from the specified collection


c- collection containing elements to be added to this list


IndexOutOfBoundsException- if the index is out of range (index < 0 || index > size())


NullPointerException- if the specified collection is null

protected void removeRange(int fromIndex, int toIndex)


fromIndex, inclusive, and


toIndex, exclusive. Shifts any succeeding elements to the left (reduces their index). This call shortens the list by


(toIndex - fromIndex)elements. (If


toIndex==fromIndex, this operation has no effect.)


removeRangein class


AbstractList


fromIndex- index of first element to be removed


toIndex- index after last element to be removed


IndexOutOfBoundsException- if


fromIndexor


toIndexis out of range (


fromIndex < 0 || fromIndex >= size() || toIndex > size() || toIndex < fromIndex)

public boolean removeAll(Collection

c)


removeAllin interface


Collection


removeAllin interface


List


removeAllin class


AbstractCollection


c- collection containing elements to be removed from this list


trueif this list changed as a result of the call


ClassCastException- if the class of an element of this list is incompatible with the specified collection (optional)


NullPointerException- if this list contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null


Collection.contains(Object)

public boolean retainAll(Collection

c)


retainAllin interface


Collection


retainAllin interface


List


retainAllin class


AbstractCollection


c- collection containing elements to be retained in this list


trueif this list changed as a result of the call


ClassCastException- if the class of an element of this list is incompatible with the specified collection (optional)


NullPointerException- if this list contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null


Collection.contains(Object)

public ListIterator

listIterator(int index)


next. An initial call to


previouswould return the element with the specified index minus one.

The returned list iterator is fail-fast.


listIteratorin interface


List


listIteratorin class


AbstractList


index- index of the first element to be returned from the list iterator (by a call to


next)


IndexOutOfBoundsException- if the index is out of range (


index < 0 || index > size())

public ListIterator

listIterator()

The returned list iterator is fail-fast.


listIteratorin interface


List


listIteratorin class


AbstractList


listIterator(int)

public Iterator

iterator()

The returned iterator is fail-fast.

public List

subList(int fromIndex, int toIndex)


fromIndex, inclusive, and


toIndex, exclusive. (If


fromIndexand


toIndexare equal, the returned list is empty.) The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations.

This method eliminates the need for explicit range operations (of the sort that commonly exist for arrays). Any operation that expects a list can be used as a range operation by passing a subList view instead of a whole list. For example, the following idiom removes a range of elements from a list:

list.subList(from, to).clear();Similar idioms may be constructed for


indexOf(Object)and


lastIndexOf(Object), and all of the algorithms in the


Collectionsclass can be applied to a subList.

The semantics of the list returned by this method become undefined if the backing list (i.e., this list) is structurally modified in any way other than via the returned list. (Structural modifications are those that change the size of this list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.)


subListin interface


List


subListin class


AbstractList


fromIndex- low endpoint (inclusive) of the subList


toIndex- high endpoint (exclusive) of the subList


IndexOutOfBoundsException- if an endpoint index value is out of range


(fromIndex < 0 || toIndex > size)


IllegalArgumentException- if the endpoint indices are out of order


(fromIndex > toIndex)

public void forEach(Consumer

action)


Iterable


Iterableuntil all elements have been processed or the action throws an exception. Unless otherwise specified by the implementing class, actions are performed in the order of iteration (if an iteration order is specified). Exceptions thrown by the action are relayed to the caller.

public Spliterator

spliterator()


Spliteratorover the elements in this list.

The

Spliterator

reports

Spliterator.SIZED

,

Spliterator.SUBSIZED

, and

Spliterator.ORDERED

.
Overriding implementations should document the reporting of additional
characteristic values.


spliteratorin interface


Iterable


spliteratorin interface


Collection


spliteratorin interface


List


Spliteratorover the elements in this list

public boolean removeIf(Predicate

filter)


Collection


removeIfin interface


Collection


filter- a predicate which returns


truefor elements to be removed


trueif any elements were removed

public void replaceAll(UnaryOperator

operator)


List


replaceAllin interface


List


operator- the operator to apply to each element

public void sort(Comparator

c)


List


Comparator.

All elements in this list must be mutually comparable using the
specified comparator (that is,

c.compare(e1, e2)

must not throw
a

ClassCastException

for any elements

e1

and

e2

in the list).

If the specified comparator is

null

then all elements in this
list must implement the

Comparable

interface and the elements’
natural ordering should be used.

This list must be modifiable, but need not be resizable.


sortin interface


List


c- the


Comparatorused to compare list elements. A


nullvalue indicates that the elements' natural ordering should be used

Submit a bug or feature For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.Copyright © 1993, 2024, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.

ArrayList là một phần của framework collection Java và nó là một lớp của gói java.util. Nó cung cấp cho chúng ta mảng động trong Java. Mặc dù, nó có thể chậm hơn so với mảng tiêu chuẩn nhưng có thể hữu ích trong các chương trình cần nhiều thao tác trong mảng. Lớp này được tìm thấy trong gói java.util. Ưu điểm chính của ArrayList là nếu chúng ta khai báo mảng thì cần phải nói đến kích thước nhưng trong ArrayList thì không cần nói đến kích thước ArrayList nếu bạn muốn nói đến kích thước thì bạn có thể làm được.

Các bài viết liên quan:

Hình minh họa:

Ví dụ 1: Việc triển khai sau đây minh họa cách tạo và sử dụng ArrayList có đề cập đến kích thước của nó.

// Java program to demonstrate the // working of ArrayList in Java import java.io.*; import java.util.*; class ArrayListExample { public static void main(String[] args) { // Size array bang 5 int n = 5; //khai bao arraylist voi khoi tao size n ArrayList

arrli = new ArrayList

(n); //thêm object vao cuoi array for (int i = 1; i <= n; i++) arrli.add(i); // in element trong arraylist System.out.println(arrli); // Remove element at index 3 arrli.remove(3); //hien thi arraylist System.out.println(arrli); // in tung element trong arraylist for (int i = 0; i < arrli.size(); i++) System.out.print(arrli.get(i) + ” “); } }

Ví dụ 2: Việc triển khai sau đây minh họa cách tạo và sử dụng ArrayList mà không đề cập đến kích thước.

// Java program to demonstrate the // working of ArrayList in Java import java.io.*; import java.util.*; class ArrayListExample { public static void main(String[] args) { //khai bao arraylist voi kich thuoc dong ArrayList

arrli = new ArrayList<>(); //them tung thanh phan vao array for (int i = 1; i <= 5; i++) arrli.add(i); // in tung element System.out.println(arrli); // xoa element tai index 3 arrli.remove(3); //hien thi array sau khi xoa System.out.println(arrli); // in elements tung cai mot for (int i = 0; i < arrli.size(); i++) System.out.print(arrli.get(i) + ” “); } }

Đầu ra:

Đầu ra giống như Ví dụ 1. Vì ArrayList là một mảng động và chúng ta không phải chỉ định kích thước khi tạo nó, nên kích thước của mảng sẽ tự động tăng lên khi chúng ta tự động thêm và xóa các phần tử. Mặc dù việc triển khai thư viện thực tế có thể phức tạp hơn, nhưng sau đây là một ý tưởng rất cơ bản giải thích hoạt động của mảng khi mảng trở nên đầy và nếu chúng ta cố gắng thêm một mục:

  • Tạo bộ nhớ có kích thước lớn hơn trên bộ nhớ heap (ví dụ: bộ nhớ có kích thước gấp đôi).
  • Sao chép các phần tử bộ nhớ hiện tại sang bộ nhớ mới.
  • Mục mới được thêm ngay bây giờ vì hiện có bộ nhớ lớn hơn.
  • Xóa bộ nhớ cũ.
ARRAYLIST en Java ☕ Lo básico para arrancar ✅
ARRAYLIST en Java ☕ Lo básico para arrancar ✅

Constructor của lớp ArrayList

Constructor Mô tả
ArrayList() Nó được sử dụng để khởi tạo một danh sách mảng trống.
ArrayList(Collection c) Nó được sử dụng để xây dựng một danh sách mảng được khởi tạo với các phần tử của collection c.
ArrayList(int capacity) Nó được sử dụng để xây dựng một danh sách mảng mà có dung lượng ban đầu được chỉ định.

Sort an ArrayList

Another useful class in the

java.util

package is the

Collections

class, which include the

sort()

method for sorting lists
alphabetically or numerically:

Example

Sort an ArrayList of Strings:


import java.util.ArrayList; import java.util.Collections; // Import the Collections class public class Main { public static void main(String[] args) { ArrayList

cars = new ArrayList

(); cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("Mazda"); Collections.sort(cars); // Sort cars for (String i : cars) { System.out.println(i); } } }


Example

Sort an ArrayList of Integers:


import java.util.ArrayList; import java.util.Collections; // Import the Collections class public class Main { public static void main(String[] args) { ArrayList

myNumbers = new ArrayList

(); myNumbers.add(33); myNumbers.add(15); myNumbers.add(20); myNumbers.add(34); myNumbers.add(8); myNumbers.add(12); Collections.sort(myNumbers); // Sort myNumbers for (int i : myNumbers) { System.out.println(i); } } }


Before reading this answer you may want to familiarize yourself with What is the difference between a variable, object, and reference?

This is what you have now


ArrayList

> outer = new ArrayList

>();
ArrayList

inner = new ArrayList

();




will create


outer -> []
inner -> []

which creates two separate lists and stores reference to them in variables

outer

and

inner

.

After


inner.add(100);
inner.add(200);

your situation looks like


outer -> []
inner -> [100, 200]

Here comes confusing part


outer.add(inner);
outer.add(inner);

Here value of

inner

variable (so reference to list [100, 200]) is placed in

outer

list two times. This means that

outer

“points to” [100, 200] list two times


//note: `reference1` == `reference2` (like 42 == 42) since they point to same object
outer -> [ reference1, reference2 ]
| |
+-------+ |
+---------------------+

inner +-> [100, 200]

This means that if you change state of list [100, 200] you will be able to see these changes using

outer.get(0)

or

outer.get(1)

or

inner

, since all of them are reference to same list.

So if we use


outer.get(0).add(300);

the

outer.get(0)

returns reference to same list as

inner

and

add(300)

adds new element to that list. Which means that after it new situation will look like


outer -> [ reference1 , reference2 ]
| |
+-------+ |
+---------------------+

inner -> [100, 200, 300]

That is why when you print

outer

you are seeing


[[100, 200, 300], [100, 200, 300]].
^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
from get(0) from get(1)

What you actually need is to create separate list so

reference1

and

reference2

will point to two separate lists. Something like


outer -> []
inner1 -> [100, 200]
inner2 -> [100, 200]

which will be later organized into


outer -> [ reference1 , reference2 ]
| |
+------+ |
↓ |
inner1 -> [100, 200] |
|
+--------------------+

inner2 -> [100, 200]

You can do it this way


List > outer = new ArrayList >();
List

inner1 = new ArrayList

();
List

inner2 = new ArrayList

();
inner1.add(100);
inner1.add(200);
inner2.add(100);
inner2.add(200);
outer.add(inner1);
outer.add(inner2);
outer.get(0).add(300);
System.out.println(outer);
//Output: [[100, 200, 300], [100, 200]]



Nội dung

Annotations In Java Tutorial - How To Create And Use Your Own Custom Annotations
Annotations In Java Tutorial – How To Create And Use Your Own Custom Annotations

Remove an Item

To remove an element, use the

remove()

method
and refer to the index number:

Example


cars.remove(0);

To remove all the elements in the

ArrayList

, use the

clear()

method:

Example


cars.clear();

Phương thức của lớp ArrayList

Phương thức Mô tả
boolean add(Object o) Nó được sử dụng để nối thêm phần tử được chỉ định vào cuối một danh sách.
void add(int index, Object element) Nó được sử dụng để chèn phần tử element tại vị trí index vào danh sách.
boolean addAll(Collection c) Nó được sử dụng để nối tất cả các phần tử trong collection c vào cuối của danh sách, theo thứ tự chúng được trả về bởi bộ lặp iterator.
boolean addAll(int index, Collection c) Nó được sử dụng để chèn tất cả các phần tử trong collection c vào danh sách, bắt đầu từ vị trí index.
void retainAll(Collection c) Nó được sử dụng để xóa những phần tử không thuộc collection c ra khỏi danh sách.
void removeAll(Collection c) Nó được sử dụng để xóa những phần tử thuộc collection c ra khỏi danh sách.
int indexOf(Object o) Nó được sử dụng để trả về chỉ mục trong danh sách với sự xuất hiện đầu tiên của phần tử được chỉ định, hoặc -1 nếu danh sách không chứa phần tử này.
int lastIndexOf(Object o) Nó được sử dụng để trả về chỉ mục trong danh sách với sự xuất hiện cuối cùng của phần tử được chỉ định, hoặc -1 nếu danh sách không chứa phần tử này.
Object[] toArray() Nó được sử dụng để trả về một mảng chứa tất cả các phần tử trong danh sách này theo đúng thứ tự.
Object[] toArray(Object[] a) Nó được sử dụng để trả về một mảng chứa tất cả các phần tử trong danh sách này theo đúng thứ tự.
Object clone() Nó được sử dụng để trả về một bản sao của ArrayList.
void clear() Nó được sử dụng để xóa tất cả các phần tử từ danh sách này.
void trimToSize() Nó được sử dụng để cắt dung lượng của thể hiện ArrayList này là kích thước danh sách hiện tại.
boolean contains(element) Kết quả trả về là true nếu tìm thấy element trong danh sách, ngược lại trả về false.
Map and HashMap in Java - Full Tutorial
Map and HashMap in Java – Full Tutorial

Keywords searched by users: arraylist de arraylist java

Java Array Of Arraylist, Arraylist Of Array | Digitalocean
Java Array Of Arraylist, Arraylist Of Array | Digitalocean
Arraylist In Java - Geeksforgeeks
Arraylist In Java – Geeksforgeeks
Arraylist Implementation In Java - Javatpoint
Arraylist Implementation In Java – Javatpoint
Initialize An Arraylist In Java - Geeksforgeeks
Initialize An Arraylist In Java – Geeksforgeeks
Realtime Use Of Arraylist In Java With Example - Scientech Easy
Realtime Use Of Arraylist In Java With Example – Scientech Easy
Java Arraylist Tutorial With Examples | Callicoder
Java Arraylist Tutorial With Examples | Callicoder
Arraylist In Java Tutorial #36 - Youtube
Arraylist In Java Tutorial #36 – Youtube
Hàm Add() Của Arraylist Hoạt Động Như Thế Nào ?
Hàm Add() Của Arraylist Hoạt Động Như Thế Nào ?
How To Create An Arraylist Of Integers | Arraylist In Java Tutorial -  Youtube
How To Create An Arraylist Of Integers | Arraylist In Java Tutorial – Youtube
Arraylist In Java With Examples
Arraylist In Java With Examples
Arraylist In Java With Examples
Arraylist In Java With Examples

See more here: kientrucannam.vn

Trả lời

Email của bạn sẽ không được hiển thị công khai. Các trường bắt buộc được đánh dấu *