The List interface in Java provides a way to store the ordered collection. It is a child interface of Collection. It is an ordered collection of objects in which duplicate values can be stored. Since List preserves the insertion order, it allows positional access and insertion of elements.Â
List Interface in Java
The List interface is found in java.util package and inherits the Collection interface. It is a factory of the ListIterator interface. Through the ListIterator, we can iterate the list in forward and backward directions. The implementation classes of the List interface are ArrayList, LinkedList, Stack, and Vector. ArrayList and LinkedList are widely used in Java programming. The Vector class is deprecated since Java 5.
List and ArrayList in Java Collection Framework
Declaration of Java List Interface
public interface List<E> extends Collection<E>Â ;
Let us elaborate on creating objects or instances in a List class. Since List is an interface, objects cannot be created of the type list. We always need a class that implements this List in order to create an object. And also, after the introduction of Generics in Java 1.5, it is possible to restrict the type of object that can be stored in the List. Just like several other user-defined ‘interfaces’ implemented by user-defined ‘classes’, List is an ‘interface’, implemented by the ArrayList class, pre-defined in java.util package.Â
Syntax of Java List
This type of safelist can be defined as:
List<Obj> list = new ArrayList<Obj> ();
Note: Obj is the type of the object to be stored in List
Example of Java List
Java
import java.util.*;
class GFG {
public static void main(String[] args)
{
List<Integer> l1 = new ArrayList<Integer>();
l1.add(0, 1);
l1.add(1, 2);
System.out.println(l1);
List<Integer> l2 = new ArrayList<Integer>();
l2.add(1);
l2.add(2);
l2.add(3);
l1.addAll(1, l2);
System.out.println(l1);
l1.remove(1);
System.out.println(l1);
System.out.println(l1.get(3));
l1.set(0, 5);
System.out.println(l1);
}
}
|
Output
[1, 2]
[1, 1, 2, 3, 2]
[1, 2, 3, 2]
2
[5, 2, 3, 2]
Now let us perform various operations using List Interface to have a better understanding of the same. We will be discussing the following operations listed below and later on implementing them via clean Java codes.
Operations in a Java List Interface
Since List is an interface, it can be used only with a class that implements this interface. Now, let’s see how to perform a few frequently used operations on the List. Â
- Operation 1: Adding elements to List class using add() method
- Operation 2: Updating elements in List class using set() method
- Operation 3: Searching for elements using indexOf(), lastIndexOf methods
- Operation 4: Removing elements using remove() method
- Operation 5: Accessing Elements in List class using get() method
- Operation 6: Checking if an element is present in the List class using contains() method
Now let us discuss the operations individually and implement the same in the code to grasp a better grip over it.
1. Adding elements to List class using add() method
In order to add an element to the list, we can use the add() method. This method is overloaded to perform multiple operations based on different parameters.
Parameters: Â It takes 2 parameters, namely:Â
- add(Object): This method is used to add an element at the end of the List.
- add(int index, Object): This method is used to add an element at a specific index in the List
Example:Â
Java
import java.util.*;
class GFG {
public static void main(String args[])
{
List<String> al = new ArrayList<>();
al.add("Geeks");
al.add("Geeks");
al.add(1, "For");
System.out.println(al);
}
}
|
Output
[Geeks, For, Geeks]
2. Updating elements
After adding the elements, if we wish to change the element, it can be done using the set() method. Since List 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
import java.util.*;
class GFG {
public static void main(String args[])
{
List<String> al = new ArrayList<>();
al.add("Geeks");
al.add("Geeks");
al.add(1, "Geeks");
System.out.println("Initial ArrayList " + al);
al.set(1, "For");
System.out.println("Updated ArrayList " + al);
}
}
|
Output
Initial ArrayList [Geeks, Geeks, Geeks]
Updated ArrayList [Geeks, For, Geeks]
3. Searching for elementsÂ
Searching for elements in the List interface is a common operation in Java programming. The List interface provides several methods to search for elements, such as the indexOf(), lastIndexOf() methods.
The indexOf() method returns the index of the first occurrence of a specified element in the list, while the lastIndexOf() method returns the index of the last occurrence of a specified element.
Parameters:
-  indexOf(element): Returns the index of the first occurrence of the specified element in the list, or -1 if the element is not found   Â
- Â lastIndexOf(element): Returns the index of the last occurrence of the specified element in the list, or -1 if the element is not found
Example:
Java
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args)
{
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(2);
int index = numbers.indexOf(2);
System.out.println(
"The first occurrence of 2 is at index "
+ index);
int lastIndex = numbers.lastIndexOf(2);
System.out.println(
"The last occurrence of 2 is at index "
+ lastIndex);
}
}
|
Output
The first occurrence of 2 is at index 1
The last occurrence of 2 is at index 3
4. Removing Elements
In order to remove an element from a list, we can use the remove() method. This method is overloaded to perform multiple operations based on different parameters. They are:
Parameters: Â
- remove(Object): This method is used to simply remove an object from the List. If there are multiple such objects, then the first occurrence of the object is removed.
- remove(int index): Since a List is indexed, this method takes an integer value which simply removes the element present at that specific index in the List. 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
import java.util.ArrayList;
import java.util.List;
class GFG {
public static void main(String args[])
{
List<String> al = new ArrayList<>();
al.add("Geeks");
al.add("Geeks");
al.add(1, "For");
System.out.println("Initial ArrayList " + al);
al.remove(1);
System.out.println("After the Index Removal " + al);
al.remove("Geeks");
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]
5. Accessing Elements
In order to access an element in the list, we can use the get() method, which returns the element at the specified index
Parameters:
get(int index): This method returns the element at the specified index in the list.
Example:
Java
import java.util.*;
class GFG {
public static void main(String args[])
{
List<String> al = new ArrayList<>();
al.add("Geeks");
al.add("For");
al.add("Geeks");
String first = al.get(0);
String second = al.get(1);
String third = al.get(2);
System.out.println(first);
System.out.println(second);
System.out.println(third);
System.out.println(al);
}
}
|
Output
Geeks
For
Geeks
[Geeks, For, Geeks]
6. Checking if an element is present in the List
In order to check if an element is present in the list, we can use the contains() method. This method returns true if the specified element is present in the list, otherwise, it returns false.
Parameters:
contains(Object): This method takes a single parameter, the object to be checked if it is present in the list.
Example:
Java
import java.util.*;
class GFG {
public static void main(String args[])
{
List<String> al = new ArrayList<>();
al.add("Geeks");
al.add("For");
al.add("Geeks");
boolean isPresent = al.contains("Geeks");
System.out.println("Is Geeks present in the list? "
+ isPresent);
}
}
|
Output
Is Geeks present in the list? true
Complexity of List Interface in Java
|
Adding Element in List Interface
|
O(1)
|
O(1)
|
|
Remove Element from List Interface
|
O(N)
|
O(N)
|
|
Replace Element in List Interface
|
O(N)
|
O(N)
|
|
Traversing List Interface
|
O(N)
|
O(N)
|
Iterating over List Interface in Java
Till now we are having a very small input size and we are doing operations manually for every entity. Now let us discuss various ways by which we can iterate over the list to get them working for a larger sample set. Â
Methods: There are multiple ways to iterate through the List. 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 a loop.Â
Example:Â
Java
import java.util.*;
public class GFG {
public static void main(String args[])
{
List<String> al = new ArrayList<>();
al.add("Geeks");
al.add("Geeks");
al.add(1, "For");
for (int i = 0; i < al.size(); i++) {
System.out.print(al.get(i) + " ");
}
System.out.println();
for (String str : al)
System.out.print(str + " ");
}
}
|
Output
Geeks For Geeks
Geeks For Geeks
Methods of the List Interface
Since the main concept behind the different types of lists is the same, the list interface contains the following methods:
| add(int index, element) |
This method is used with Java List Interface to add an element at a particular index in the list. When a single parameter is passed, it simply adds the element at the end of the list. |
| addAll(int index, Collection collection) |
This method is used with List Interface in Java to add all the elements in the given collection to the list. When a single parameter is passed, it adds all the elements of the given collection at the end of the list. |
| size() |
This method is used with Java List Interface to return the size of the list. |
| clear() |
This method is used to remove all the elements in the list. However, the reference of the list created is still stored. |
| remove(int index) |
This method removes an element from the specified index. It shifts subsequent elements(if any) to left and decreases their indexes by 1. |
| remove(element) |
This method is used with Java List Interface to remove the first occurrence of the given element in the list. |
| get(int index) |
This method returns elements at the specified index. |
| set(int index, element) |
This method replaces elements at a given index with the new element. This function returns the element which was just replaced by a new element. |
| indexOf(element) |
This method returns the first occurrence of the given element or -1 if the element is not present in the list. |
| lastIndexOf(element) |
This method returns the last occurrence of the given element or -1 if the element is not present in the list. |
| equals(element) |
This method is used with Java List Interface to compare the equality of the given element with the elements of the list. |
| hashCode() |
This method is used with List Interface in Java to return the hashcode value of the given list. |
| isEmpty() |
This method is used with Java List Interface to check if the list is empty or not. It returns true if the list is empty, else false. |
| contains(element) |
This method is used with List Interface in Java to check if the list contains the given element or not. It returns true if the list contains the element. |
| containsAll(Collection collection) |
This method is used with Java List Interface to check if the list contains all the collection of elements. |
| sort(Comparator comp) |
This method is used with List Interface in Java to sort the elements of the list on the basis of the given comparator. |
Java List vs Set
Both the List interface and the Set interface inherits the Collection interface. However, there exists some differences between them.
| The List is an ordered sequence. |
The Set is an unordered sequence. |
| List allows duplicate elements |
Set doesn’t allow duplicate elements. |
| Elements by their position can be accessed. |
Position access to elements is not allowed. |
| Multiple null elements can be stored. |
The null element can store only once. |
| List implementations are ArrayList, LinkedList, Vector, Stack |
Set implementations are HashSet, LinkedHashSet. |
Classes Association with a Java List Interface
Now let us discuss the classes that implement the List Interface for which first do refer to the pictorial representation below to have a better understanding of the List interface. It is as follows:Â
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 as follows:
- 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.
We will proceed in this manner.Â
- ArrayList
- Vector
- Stack
- LinkedList
Let us discuss them sequentially and implement the same to figure out the working of the classes with the List interface.Â
1. ArrayList
An ArrayList class which is implemented in the collection framework 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. Let’s see how to create a list object using this class.Â
Example:
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
int n = 5;
List<Integer> arrli = new ArrayList<Integer>(n);
for (int i = 1; i <= n; i++)
arrli.add(i);
System.out.println(arrli);
arrli.remove(3);
System.out.println(arrli);
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
2. Vector
Vector is a class that is implemented in the collection framework implements a growable array of objects. Vector implements a dynamic array that means it can grow or shrink as required. Like an array, it contains components that can be accessed using an integer index. Vectors basically fall in legacy classes but now it is fully compatible with collections. Let’s see how to create a list object using this class.Â
Example:
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
int n = 5;
List<Integer> v = new Vector<Integer>(n);
for (int i = 1; i <= n; i++)
v.add(i);
System.out.println(v);
v.remove(3);
System.out.println(v);
for (int i = 0; i < v.size(); i++)
System.out.print(v.get(i) + " ");
}
}
|
Output
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5
3. Stack
Stack is a class that is implemented in the collection framework and extends the vector class models and implements the Stack data structure. The class is based on the basic principle of last-in-first-out. In addition to the basic push and pop operations, the class provides three more functions of empty, search and peek. Let’s see how to create a list object using this class.
Example:
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
int n = 5;
List<Integer> s = new Stack<Integer>();
for (int i = 1; i <= n; i++)
s.add(i);
System.out.println(s);
s.remove(3);
System.out.println(s);
for (int i = 0; i < s.size(); i++)
System.out.print(s.get(i) + " ");
}
}
|
Output
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5
4. LinkedList
LinkedList is a class that is implemented in the collection framework which inherently implements the linked list data structure. It is a linear data structure where the elements are not stored in contiguous locations and every element is a separate object with a data part and address part. The elements are linked using pointers and addresses. Each element is known as a node. Due to the dynamicity and ease of insertions and deletions, they are preferred over the arrays. Let’s see how to create a list object using this class.
Example:
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
int n = 5;
List<Integer> ll = new LinkedList<Integer>();
for (int i = 1; i <= n; i++)
ll.add(i);
System.out.println(ll);
ll.remove(3);
System.out.println(ll);
for (int i = 0; i < ll.size(); i++)
System.out.print(ll.get(i) + " ");
}
}
|
Output
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5
Please Login to comment...