Which field or method of the ArrayList class will return the number of elements stored in the ArrayList?

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:

Which field or method of the ArrayList class will return the number of elements stored in the ArrayList?

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

last modified November 12, 2021

Java ArrayList tutorial shows how to work with ArrayList collection in Java. Located in the java.util package, ArrayList is an important collection of the Java collections framework.

Java collections framework is a unified architecture for representing and manipulating collections, enabling collections to be manipulated independently of implementation details. A collection is an object that represents a group of objects.

ArrayList Methods In Java

The following table lists all the methods that are provided by the ArrayList class.

Method	Method Prototype	Method Description
Add	boolean add(E e)	Adds given element e to the end of the list.
void add(int index, E element)	Adds given element ‘element’ at the specified position ‘index’.
AddAll	boolean addAll (Collection extends E> c)	Adds all the elements in the given collection c to the end of the list.
boolean addAll (int index, Collection extends E> c)	Adds all the elements in the given collection c at the position specified by the ‘index’ in the list.
Clear	void clear()	Clears the list by removing all the elements from the list.
Clone	Object clone()	Makes a shallow copy of the given ArrayList.
Contains	boolean contains(Object o)	Checks if the list contains the given element ‘o’. Returns true if the element is present.
ensureCapacity	void ensureCapacity (int minCapacity)	Increases the capacity of the ArrayList to ensure it has the minCapacity.
Get	E get(int index)	Returns the element in the list present at the position specified by ‘index’.
indexOf	int indexOf(Object o)	Returns the index of the first occurrence of element o in the list. -1 if element o is not present in the list.
isEmpty	boolean isEmpty()	Checks if the given list is empty.
Iterator	Iterator iterator()	Returns an iterator to traverse over the list elements in the proper sequence.
lastIndexOf	int lastIndexOf(Object o)	Returns the index of the last occurrence of the specified element o in the list. -1 if the element is not present in the list.
listIterator	ListIterator listIterator()	Returns list iterator to traverse over the elements of the given list.
ListIterator listIterator(int index)	Returns the list iterator starting from the specified position ‘index’ to traverse over the elements of the given list.
remove	E remove(int index)	Deletes element at the ‘index’ in the ArrayList.
boolean remove(Object o)	Deletes the first occurrence of element o from the list.
removeAll	boolean removeAll(Collection c)	Removes all the elements from the list that match the elements in given collection c.
removeRange	protected void removeRange (int fromIndex, int toIndex)	Removes elements specified in the given range, fromIndex (inclusive) to toIndex (exclusive) from the list.
retainAll	boolean retainAll(Collection c)	Retains those elements in the list that match the elements in the given collection c.
set	E set(int index, E element)	Sets the element value at given ‘index’ to the new value given by ‘element’.
size	int size()	Returns the total number of elements or length of the list.
subList	List subList(int fromIndex, int toIndex)	Returns a subList between given range, fromIndex to toIndex for the given list.
toArray	Object[] toArray()	Converts the given list into an array.
T[] toArray(T[] a)	Converts the given list into an array of the type given by a.
trimToSize	void trimToSize()	Trims the ArrayList capacity to the size or number of elements present in the list.

Next, we will discuss each of these methods from the ArrayList function API in detail and present programming examples. After discussing all the methods listed above, we will also take up some specific operations that are carried out using ArrayLists which are not a part of the ArrayList function API.

ArrayList add

Prototype: boolean add (E e)
Parameters: e=> Element to be added to the ArrayList.
Return Value: true=> Element successfully added.
Description: Adds the given element e to the end of the list.

II.

Prototype: void add (int index, E element)

Parameters:

index=> Position at which the element is to be added.
Element=> Element to be added to the ArrayList.

Return Value: void

Description: Adds given element ‘element’ at the specified position ‘index’ by shifting the element at that position and subsequent elements to the right.

Exceptions: IndexOutOfBoundsException => If the specified index is out of the range.

ArrayList addAll

Prototype: boolean addAll (Collection c)
Parameters: c=> Collection whose elements are to be added to the ArrayList.
Return Value: true=> If the operation has altered the ArrayList.

Description: Adds all the elements in the given collection c to the end of the list. The result of the operation is undefined if the collection is altered when the operation is in progress.

Exceptions: NullPointerException => If given collection c is null.

Prototype: boolean addAll (int index, Collection c)
Parameters: index=> Position at which the elements in the given collection are to be added.
Return Value: true=> If the list has changed as a result of the operation.

Description: Adds all the elements in the given collection c at the position specified by the ‘index’ in the list. The element at the specified index and subsequent elements are shifted to the right. The result of the operation is undefined if the collection being added is altered when the operation is in progress.

Exceptions: IndexOutOfBoundsException: if the index where the collection is to be added is out of bounds
NullPointerException: if the given collection c is null.

The following Java program demonstrates the usage of add and addAll methods.

import java.util.*; class Main{ public static void main(String args[]){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add("Delhi"); city_List.add("Mumbai"); city_List.add("Chennai"); city_List.add("Kolkata"); //print the list System.out.println("Initial ArrayList:" + city_List); //add an element at index 1 using add method overload city_List.add(1, "NYC"); //print the list System.out.println("\nrrayList after adding element at index 1:" + city_List); //define a second list ArrayList more_Cities = new ArrayList(Arrays.asList("Pune", "Hyderabad")); //use addAll method to add the list to ArrayList at index 4 city_List.addAll(4,more_Cities); //print the list System.out.println("\nArrayList after adding list at index 4:" + city_List); } }

Output:

Initial ArrayList:[Delhi, Mumbai, Chennai, Kolkata]
rrayList after adding element at index 1:[Delhi, NYC, Mumbai, Chennai, Kolkata]
ArrayList after adding list at index 4:[Delhi, NYC, Mumbai, Chennai, Pune, Hyderabad, Kolkata]

Java ArrayList Implementation

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

// 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 <= n; i++)

arrli.add(i);

// Printing elements

System.out.println(arrli);

// Remove element at index 3

arrli.remove(3);

// Displaying the ArrayList

// after deletion

System.out.println(arrli);

// Printing elements one by one

for (int i = 0; i < arrli.size(); i++)

System.out.print(arrli.get(i) + " ");

}
}

Output [1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5

Since ArrayList is a dynamic array and we do not have to specify the size while creating it, the size of the array automatically increases when we dynamically add and remove items. Though the actual library implementation may be more complex, the following is a very basic idea explaining the working of the array when the array becomes full and if we try to add an item:

Creates a bigger-sized memory on heap memory (for example memory of double size).
Copies the current memory elements to the new memory.
New item is added now as there is bigger memory available now.
Delete the old memory.

Important Features:

ArrayList inherits AbstractList class and implements the List interface.
ArrayList is initialized by the size. However, the size is increased automatically if the collection grows or shrinks if the objects are removed from the collection.
Java ArrayList allows us to randomly access the list.
ArrayList can not be used for primitive types, like int, char, etc. We need a wrapper class for such cases.
ArrayList in Java can be seen as a vector in C++.
ArrayList is not Synchronized. Its equivalent synchronized class in Java is Vector.

Let’s understand the Java ArrayList in depth. Look at the below image:

In the above illustration, AbstractList, CopyOnWriteArrayList, and the AbstractSequentialList are the classes that implement the list interface. A separate functionality is implemented in each of the mentioned classes. They are:

AbstractList: This class is used to implement an unmodifiable list, for which one needs to only extend this AbstractList Class and implement only the get() and the size() methods.
CopyOnWriteArrayList: This class implements the list interface. It is an enhanced version of ArrayList in which all the modifications(add, set, remove, etc.) are implemented by making a fresh copy of the list.
AbstractSequentialList: This class implements the Collection interface and the AbstractCollection class. This class is used to implement an unmodifiable list, for which one needs to only extend this AbstractList Class and implement only the get() and the size() methods.

Constructors in the ArrayList

In order to create an ArrayList, we need to create an object of the ArrayList class. The ArrayList class consists of various constructors which allow the possible creation of the array list. The following are the constructors available in this class:

1. ArrayList(): This constructor is used to build an empty array list. If we wish to create an empty ArrayList with the name arr, then, it can be created as:

ArrayList arr = new ArrayList();

2. ArrayList(Collection c): This constructor is used to build an array list initialized with the elements from the collection c. Suppose, we wish to create an ArrayList arr which contains the elements present in the collection c, then, it can be created as:

ArrayList arr = new ArrayList(c);

3. ArrayList(int capacity): This constructor is used to build an array list with initial capacity being specified. Suppose we wish to create an ArrayList with the initial size being N, then, it can be created as:

ArrayList arr = new ArrayList(N);

Methods in Java ArrayList

Method	Description
add(int index, Object element)	This method is used to insert a specific element at a specific position index in a list.
add(Object o)	This method is used to append a specific element to the end of a list.
addAll(Collection C)	This method is used to append all the elements from a specific collection to the end of the mentioned list, in such an order that the values are returned by the specified collection’s iterator.
addAll(int index, Collection C)	Used to insert all of the elements starting at the specified position from a specific collection into the mentioned list.
clear()	This method is used to remove all the elements from any list.
clone()	This method is used to return a shallow copy of an ArrayList.
contains?(Object o)	Returns true if this list contains the specified element.
ensureCapacity?(int minCapacity)	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.
forEach?(Consumer action)	Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.
get?(int index)	Returns the element at the specified position in this list.
indexOf(Object O)	The index the first occurrence of a specific element is either returned, or -1 in case the element is not in the list.
isEmpty?()	Returns true if this list contains no elements.
lastIndexOf(Object O)	The index of the last occurrence of a specific element is either returned or -1 in case the element is not in the list.
listIterator?()	Returns a list iterator over the elements in this list (in proper sequence).
listIterator?(int index)	Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
remove?(int index)	Removes the element at the specified position in this list.
remove?(Object o)	Removes the first occurrence of the specified element from this list, if it is present.
removeAll?(Collection c)	Removes from this list all of its elements that are contained in the specified collection.
removeIf?(Predicate filter)	Removes all of the elements of this collection that satisfy the given predicate.
removeRange?(int fromIndex, int toIndex)	Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
retainAll?(Collection 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

// 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);

}
}

Output: [Geeks, For, Geeks]

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

// 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);

}
}

Output: Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]

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

// 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);

}
}

Output: Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]

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

// 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 + " ");

}
}

Output: Geeks For Geeks Geeks For Geeks

Must Read: Array vs ArrayList in Java

Article Tags :

Java

Technical Scripter

Java - util package

Java-ArrayList

Java-Collections

java-list

Practice Tags :

Java

Java-Collections

Read Full Article

ArrayList size() method in Java with Examples

The size() method of java.util.ArrayList class is used to get the number of elements in this list.

Syntax:

public int size()

Returns Value: This method returns the number of elements in this list.

Below are the examples to illustrate the size() method.

Example 1:

// Java program to demonstrate 
// size() method 
// for Integer value 

import java.util.*;

public class GFG1 {

public static void main(String[] argv)

throws Exception

{

try {

// Creating object of ArrayList

ArrayList

arrlist = new ArrayList();

// Populating arrlist1

arrlist.add(1);

arrlist.add(2);

arrlist.add(3);

arrlist.add(4);

arrlist.add(5);

// print arrlist

System.out.println("Before operation: "

+ arrlist);

// getting total size of arrlist

// using size() method

int size = arrlist.size();

// print the size of arrlist

System.out.println("Size of list = "

+ size);

}

catch (IndexOutOfBoundsException e) {

System.out.println("Exception thrown: "

+ e);

}

}
}

Output: Before operation: [1, 2, 3, 4, 5] Size of list = 5

Example 2:

// Java program to demonstrate 
// size() method 
// for String value 

import java.util.*;

public class GFG1 {

public static void main(String[] argv)

throws Exception

{

try {

// Creating object of ArrayList

ArrayList

arrlist = new ArrayList();

// Populating arrlist1

arrlist.add("A");

arrlist.add("B");

arrlist.add("C");

// print arrlist

System.out.println("Before operation: "

+ arrlist);

// getting total size of arrlist

// using size() method

int size = arrlist.size();

// print the size of arrlist

System.out.println("Size of list = "

+ size);

}

catch (IndexOutOfBoundsException e) {

System.out.println("Exception thrown: "

+ e);

}

}
}

Output: Before operation: [A, B, C] Size of list = 3

Article Tags :

Java

Java - util package

Java-ArrayList

Java-Collections

Java-Functions

Practice Tags :

Java

Java-Collections

Read Full Article

Which field or method of the ArrayList class will return the number of elements stored in the ArrayList?

Why ArrayList is better than Array?

Java ArrayList

ArrayList Methods In Java

ArrayList add

ArrayList addAll

ArrayList in Java

Constructors in the ArrayList

Methods in Java ArrayList

ArrayList size() method in Java with Examples

Bài Viết Liên Quan

Có thể bạn quan tâm

Xem Nhiều

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội