List is a sequence of elements. In Java list can be implemented using List interface.
List In Java
In this section we will read about the List data structure in Java and how the List data structure can be implemented in Java.
List data structure is implemented in Java using List interface. List interface allows to insert the element at the specified index as well as to access the element from specified index. Using this interface the elements can also be searched into list. A list may contain the duplicate elements. The List interface provides methods for performing operations like add elements, remove elements, iterate over elements etc. List is indexed based implementation like an array. LinkedList class is one of the implementation among most of the implementation of List interface, it provides an iterator called ListIterator to access elements bi-directional, and allows for inserting and replacing the elements.
Methods Of List Interface
- boolean add(E e) : This method adds the specified element
at end of the list.
Syntax : boolean add(E e)
- void add(int index, E element) : This method adds the given
element at the given position in the list.
Syntax : void add(int index, E element)
- boolean addAll(Collection<? extends E> c) : This
method adds the all the elements in the given Collection at the end of the list.
Syntax : boolean addAll(Collection<? extends E> c)
- boolean addAll(int index, Collection<? extends E> c) :
This method adds all the elements in the given Collection at the given position
in the list.
Syntax : boolean addAll(int index, Collection<? extends E> c)
- void clear() : This method clears all the elements from the
list.
Syntax : void clear()
- boolean contains(Object o) : This method is used to check
whether the given object is present in the list or not. It returns true if
element is present otherwise, false.
Syntax : boolean contains(Object o)
- boolean containsAll(Collection<?> c) : This method is
used to check for all the elements of a collection that whether they are present
in the list or not. It returns true if all elements are present otherwise,
false.
Syntax : boolean containsAll(Collection<?> c)
- boolean equals(Object o) : This method checks the given
element that whether, it is equal to any of the element in a list.
Syntax : boolean equals(Object o)
- E get(int index) : This method is used to find the element
at the given index in the list.
Syntax : E get(int index)
- int hashCode() : This method gives the hash code of list.
Syntax : int hashCode()
- int indexOf(Object o) : This method gives the position of
first occurrence of the given element in the list or -1 if the element is not
present.
Syntax : int indexOf(Object o)
- boolean isEmpty() : This method is used to check whether
the list is contains element or not.
Syntax : boolean isEmpty()
- Iterator<E> iterator() : This method is used to
iterate over the element in proper sequence.
Syntax : Iteratoriterator()
- int lastIndexOf(Object o) : This method is used to find the
position of last occurrence of the given element in the list or -1 if the
element is not present.
Syntax : int lastIndexOf(Object o)
- ListIterator<E> listIterator() : This method is used
to get the list iterator over element in the list.
Syntax : ListIterator<E> listIterator()
- ListIterator<E> listIterator(int index) : This method
is used to get the list iterator over element in the list starts from the given
index.
Syntax : ListIterator<E> listIterator(int index)
- E remove(int index) : This method is used to remove
elements at the given position from the list.
Syntax : E remove(int index)
- boolean remove(Object o) : This method is used to remove
the given elements from the list.
Syntax : boolean remove(Object o)
- boolean removeAll(Collection<?> c) : This method is
used to remove all the elements from list contained by a given collection.
Syntax : boolean removeAll(Collection<?> c)
- boolean retainAll(Collection<?> c) : This method is
used to remove all elements from the list except the elements contained by a
given collection.
Syntax : boolean retainAll(Collection<?> c)
- E set(int index, E element) : This method replaces the
given element at the given position.
Syntax : E set(int index, E element)
- int size() : This method gives the number of available
elements in the list.
Syntax : int size()
- List<E> subList(int fromIndex, int toIndex) : This
method is used create a sublist from the list started from the given index and
ends with the given index. In the sublist the starting index element is
inclusive whereas, the toIndex is exclusive.
Syntax : ListsubList(int fromIndex, int toIndex)
- Object[] toArray() : This method is used to convert a list
to an array that contains all the elements in proper sequence.
Syntax : Object[] toArray()
-
T[] toArray(T[] a) : This method is used to convert a list to an array that contains all the elements in proper sequence.
Syntax :T[] toArray(T[] a)
Example
Here an example is being given which will demonstrate you about how to list data structure can be implemented in Java. In this example we will create a Java class where I will use the List interface and its implementing class LinkedList. Then we will insert some elements to list and then we will use methods on the list object. We will fetch element at the specified index from the list, iterate over the list, replace the specified list and many more task we will perform on the list.
ListInJavaExample.java
import java.util.List;
import java.util.LinkedList;
import java.util.ListIterator;
public class ListInJavaExample {
public static void main(String args[])
{
List list = new LinkedList();
//add elements to the list.
list.add("Java");
list.add(".Net");
list.add("C");
list.add("C++");
//iterate over the element
ListIterator litr = list.listIterator();
System.out.println("Elements In List In Forward Order:");
while(litr.hasNext())
{
//iterate in forward direction
System.out.print(litr.next()+",");
}
System.out.println("\nElements In List In Backward Order");
while(litr.hasPrevious())
{
System.out.print(litr.previous()+",");
}
//insert new element at the specified index
list.add(3, "Fortran");
ListIterator litr1 = list.listIterator();
System.out.println("\nElements In List After adding new element at specified index:");
while(litr1.hasNext())
{
//iterate in forward direction
System.out.print(litr1.next()+",");
}
//replace element at the specified index
list.set(3, "Pascal");
ListIterator litr2 = list.listIterator();
System.out.println("\nElements In List After replacing new element at specified index:");
while(litr2.hasNext())
{
//iterate in forward direction
System.out.print(litr2.next()+",");
}
//check for the availability of elements
boolean bol = list.contains("Pascal");
System.out.println("\nWhether The Element 'Pascal' Is Available In List : "+bol);
}
}
Output
When you will compile and execute the above example you will get the output as follows :
