List Interface In Java: This list interface is an extended collection interface which gives optimal solutions with concepts like positional access, iteration, etc. This post, we are going to discuss various operation on a list interface in Java.
The topics which are going to discuss on this post is:
- List interface in Java
- Creating List Objects
- Different Method of List Interface
- Different Operation On List Interface
List Interface In Java
When our requirement is to represent a group of individual objects as a single entity where duplicates are allowed and insertion order is preserved than that time we should go for the List interface. As the List interface have preserve the order so whatever the operation like inserted, accessed, iterated and removed according to the order in which they appear internally in the Java List.
Each element in List has an index so we can access the elements with the help of indexes, which also helps us in searching an elements on a List interface.
In Java Collection frmaework we have some classes which are implemented the List interface that classes are ArrayList, LinkedList, Vectors and Stack classes.
Following is the syntax to implement the list interface in Java.
public interface List<E> extends Collection<E>
Creating List Objects
As from the above discussion we get to know that list is an interface and we can create the instance of List interface by the following ways:
List obj1 = new ArrayList(); List obj2 = new LinkedList(); List obj3 = new Vector(); List obj4 = new Stack(); //After the release of generics, we can restrict the type of the object as well. List <object> list = new ArrayList<object>();
List Interface Methods
Method | Description |
| void add(int index, E element) | It is used to insert elements at a particular position |
| boolean add(E e) | It appends the elements at the end of the list |
| boolean addAll(int index, Collection<? extends E> c) | It appends elements in a specified collection at the end of the list |
| void clear() | Removes all the elements from the list |
| boolean equals(object o) | It compares the specified object with elements in the list |
| int hashcode() | It returns the hash code value of the list |
| E get(int index) | It fetches elements from a particular location of the list |
| boolean isEmpty() | It checks if the list is empty or not |
| int lastIndexOf(object o) | Returns the index value of the specified object |
| Object[] toArray() | It returns an array with all the elements in a list in a correct order |
| T[] toArray(T[] a) | Returns an array with all the elements in a list |
| boolean contains(object o) | It returns true if the specified element is present in the list |
| boolean containsAll(Collection<?>c) | It checks for multiple elements in a list |
| int indexOf(Object o) | Returns the index of the element in the first occurrence |
| E remove(int index) | Removes the elements at the specified location |
| boolean remove(Object o) | It removes the first occurrence of the specified element |
| boolean removeAll(Collection<?> c) | Removes all elements from the list |
| void replaceAll(UnaryOperator operator) | Replaces all elements with specified values |
| void retainAll(Collection<?> c) | Retains all elements at a specified location |
| E set(int index, E element) | Replaces specified element at the specified location |
| void sort(Comparator<? Super E> c) | Sorts the list based on specified comparator |
| Spliterator spliterator() | Creates spliterator over elements |
| List<E> subList (int fromIndex, int toIndex) | Fetches elements in a given range |
| int size() | Returns the number of elements in a list |
As you can see from the above table List interface provides so many methods. By using those methods we can do different operations like positional access, searching operation, iteration, etc.
So Lets take some example and try to understand how the List interface is working:
Positional Access:
In the below example we are going to learn how we can access an elements of List interface by using the index of that elements
public class Demo {
public static void main(String[] args){
List<Integer> list = new ArrayList<Integer> ();
list.add(0,1);
list.add(1,3);
list.add(2,5);
list.add(3,7);
System.out.println(list);
list.remove(3);
System.out.println(list.get(2));
list.set(3,5);
System.out.println(list);
}
}
Search Operation Using List Interface:
List interface provides some methods for search an element and returns the numeric postion of that elements. Those methods are :
int indexOf(Object o) int lastIndexOf(Object o)
If there are somany elements in the list then for traverse or iterate those elements we can use the Listiterator. List iterator is a bidirectional iterator that means we can traverse in both forward and backward direction. We have discusses in details in a separate post of Iterators in Java.
Range-view In List Interface:
List also providing some methods to get some of the portion of elements between two indices. For this operator list interface is providing List subList(int fromIndex,int toIndex) method, you can use this method like below:
// Java program to demonstrate subList operation
// on List interface.
import java.util.*;
public class ListDemo
{
public static void main (String[] args)
{
// Type safe array list, stores only string
List<String> l = new ArrayList<String>(5);
l.add(“GeeksforGeeks”);
l.add(“Practice”);
l.add(“GeeksQuiz”);
l.add(“IDE”);
l.add(“Courses”);
List<String> range = new ArrayList<String>();
// Return List between 2nd(including)
// and 4th element(excluding)
range = l.subList(2, 4);
System.out.println(range);
}
}
Important Points Of List Interface
- Java List is a member of the Java Collections Framework.
- The list allows you to add duplicate elements.
- The list allows you to have ‘null’ elements.
- In list, got many default methods in Java 8, for example, replaceAll, sort, and spliterator.
- List indexes start from 0, just like arrays.
- The list supports Generics and we should use it whenever possible. Using Generics with List will avoid ClassCastException at runtime.
Ref: article
Leave a Reply