List Interface In Java

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 we require 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 has preserved 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 element on a List interface.

In the Java Collection framework, 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

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.

Write a Program to Add Element In List In Java?

package com.java.Softwaretestingblog;
import java.util.ArrayList;
import java.util.List;
public class AddingElementsInList {
   public static void main(String[] args) {
      // TODO Auto-generated method stub
      List<String> li=new ArrayList<String>();
      li.add("Manoj");
      li.add("Kumar");
      li.add("Rana");
      System.out.println(li); // tostring is bydefault override in collection
   }
}

Execution: The output link

Output:

[Software , Testing , Blog]

Ref: article
Remove Element Java Program: Write a Program to Remove Element From List In Java With Example?

Check Also: Find Fibonacci Series In Java

package com.java.Softwaretestingblog;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MyItrRemoveElement {
   public static void main(String[] args) {
      // TODO Auto-generated method stub
      String removeElem = "Perl";
      List<> myList = new ArrayList();
      myList.add("Java");
      myList.add("Unix");
      myList.add("Oracle");
      myList.add("C++");
      myList.add("Perl");
      System.out.println("Before remove:");
      System.out.println(myList);
      Iterator<> itr = myList.iterator();
      while(itr.hasNext())
      {
         if(removeElem.equals(itr.next())){
            itr.remove();
         }
      }
      System.out.println("After remove:");
      System.out.println(myList);
   }
}

Execution: Chk For the execution result link

Check Also: Retrieve Vector Elements

Output:

Before remove: [Java, Unix, Oracle, C++, Perl]
After remove: [Java, Unix, Oracle, C++]