List In Java
List is a sequence of elements. In Java list can be implemented using List interface.
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 : Iterator iterator()
- 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 : List subList(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 :

Download Source Code
Ads