Java ArrayList
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 objectIf you don't know what a package is, read our Java Packages Tutorial.
ArrayList in Java
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.
Illustration:
Example: The following implementation demonstrates how to create and use an ArrayList.
|
// 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 of the
// ArrayList
int n = 5;
// Declaring the ArrayList with
// initial size n
ArrayList arrli
= new ArrayList[n];
// Appending new elements at
// the end of the list
for [int i = 1; i c] |
Retains only the elements in this list that are contained in the specified collection. |
| set?[int index, E element] | Replaces the element at the specified position in this list with the specified element. |
| size?[] | Returns the number of elements in this list. |
| spliterator?[] | Creates a late-binding and fail-fast Spliterator over the elements in this list. |
| subList?[int fromIndex, int toIndex] | Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. |
| toArray[] | This method is used to return an array containing all of the elements in the list in the correct order. |
| toArray[Object[] O] | It is also used to return an array containing all of the elements in this list in the correct order same as the previous method. |
| trimToSize[] | This method is used to trim the capacity of the instance of the ArrayList to the list’s current size. |
Note: You can also create a generic ArrayList:
// Creating generic integer ArrayList ArrayList arrli = new ArrayList[];
Let’s see how to perform some basics operations on the ArrayList as listed which we are going to discuss further alongside implementing every operation.
- Adding element to List
- Changing elements
- Removing elements
- Iterating elements
Operation 1: Adding Elements
In order to add an element to an ArrayList, we can use the add[] method. This method is overloaded to perform multiple operations based on different parameters. They are as follows:
- add[Object]: This method is used to add an element at the end of the ArrayList.
- add[int index, Object]: This method is used to add an element at a specific index in the ArrayList.
Example:
|
// Java Program to Add elements to An ArrayList
// Importing all utility classes
import java.util.*;
// Main class
class GFG {
// Main driver method
public static void main[String args[]]
{
// Creating an Array of string type
ArrayList al = new ArrayList[];
// Adding elements to ArrayList
// Custom inputs
al.add["Geeks"];
al.add["Geeks"];
// Here we are mentioning the index
// at which it is to be added
al.add[1, "For"];
// Printing all the elements in an ArrayList
System.out.println[al];
}
}
|
Operation 2: Changing Elements
After adding the elements, if we wish to change the element, it can be done using the set[] method. Since an ArrayList is indexed, the element which we wish to change is referenced by the index of the element. Therefore, this method takes an index and the updated element which needs to be inserted at that index.
Example
|
// Java Program to Change elements in ArrayList
// Importing all utility classes
import java.util.*;
// main class
class GFG {
// Main driver method
public static void main[String args[]]
{
// Creating an Arratlist object of string type
ArrayList al = new ArrayList[];
// Adding elements to Arraylist
// Custom input elements
al.add["Geeks"];
al.add["Geeks"];
// Adding specifying the index to be added
al.add[1, "Geeks"];
// Printing the Arraylist elements
System.out.println["Initial ArrayList " + al];
// Setting element at 1st index
al.set[1, "For"];
// Printing the updated Arraylist
System.out.println["Updated ArrayList " + al];
}
}
|
Operation 3: Removing Elements
In order to remove an element from an ArrayList, we can use the remove[] method. This method is overloaded to perform multiple operations based on different parameters. They are as follows:
- remove[Object]: This method is used to simply remove an object from the ArrayList. If there are multiple such objects, then the first occurrence of the object is removed.
- remove[int index]: Since an ArrayList is indexed, this method takes an integer value which simply removes the element present at that specific index in the ArrayList. After removing the element, all the elements are moved to the left to fill the space and the indices of the objects are updated.
Example
|
// Java program to Remove Elements in ArrayList
// Importing all utility classes
import java.util.*;
// Main class
class GFG {
// 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["Geeks"];
al.add["Geeks"];
// 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["Geeks"];
// Now printing updated ArrayList
System.out.println["After the Object Removal "
+ al];
}
}
|
Operation 4: Iterating the ArrayList
There are multiple ways to iterate through the ArrayList. The most famous ways are by using the basic for loop in combination with a get[] method to get the element at a specific index and the advanced for loop.
Example
|
// Java program to Iterate the elements
// in an ArrayList
// Importing all utility classes
import java.util.*;
// Main class
class GFG {
// 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["Geeks"];
al.add["Geeks"];
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 + " "];
}
}
|
Must Read: Array vs ArrayList in Java
Why ArrayList is better than Array?
The limitation with array is that it has a fixed length so if it is full you cannot add any more elements to it, likewise if there are number of elements gets removed from it the memory consumption would be the same as it doesn’t shrink.
On the other ArrayList can dynamically grow and shrink after addition and removal of elements [See the images below]. Apart from these benefits ArrayList class enables us to use predefined methods of it which makes our task easy. Let’s see the diagrams to understand the addition and removal of elements from ArrayList and then we will see the programs.
Adding Element in ArrayList at specified position:
Removing Element from ArrayList:
There is a list of several tutorials on ArrayList at the end of this guide, refer it to understand and learn ArrayList concept fully.
Java ArrayList
Java ArrayList class uses a dynamic array for storing the elements. It is like an array, but there is no size limit. We can add or remove elements anytime. So, it is much more flexible than the traditional array. It is found in the java.util package. It is like the Vector in C++.
The ArrayList in Java can have the duplicate elements also. It implements the List interface so we can use all the methods of List interface here. The ArrayList maintains the insertion order internally.
It inherits the AbstractList class and implements List interface.
The important points about Java ArrayList class are:
- Java ArrayList class can contain duplicate elements.
- Java ArrayList class maintains insertion order.
- Java ArrayList class is non synchronized.
- Java ArrayList allows random access because array works at the index basis.
- In ArrayList, manipulation is little bit slower than the LinkedList in Java because a lot of shifting needs to occur if any element is removed from the array list.
Hierarchy of ArrayList class
As shown in the above diagram, Java ArrayList class extends AbstractList class which implements List interface. The List interface extends the Collection and Iterable interfaces in hierarchical order.
ArrayList class declaration
Let's see the declaration for java.util.ArrayList class.
Constructors of ArrayList
| ArrayList[] | It is used to build an empty array list. |
ArrayList[Collection
Chủ Đề |