Java List Interface

Java is a highly flexible and extensively utilized programming language that presents a strong array of data structures for efficiently managing groups of objects. Among the essential data structures within Java is the List interface, which furnishes a sequentially arranged assortment of elements with adaptable sizing. This interface, integrated into the Java Collections Framework, furnishes a versatile and orderly approach for managing element collections. In the following segment, we will delve into the characteristics, realizations, and recommended methodologies linked with Java Lists.

In Java, the List interface allows for the organized storage of elements. It offers methods based on index positions for adding, modifying, removing, and locating elements. Lists can include duplicate elements and can store null values as well.

The List interface is located within the java.util package and extends the Collection interface. It serves as a creator of the ListIterator interface. With ListIterator, we have the capability to traverse the list both forwards and backwards. The concrete classes that implement the List interface include ArrayList, LinkedList, Stack, and Vector. Among these, ArrayList and LinkedList are extensively utilized in Java development. It is worth noting that the Vector class has been marked as deprecated starting from Java 5.

List Interface Declaration

public interface List<E> extends Collection<E>

Java List Class Methods

How to create List?

The List interface is implemented by the ArrayList and LinkedList classes. Below are examples demonstrating how to instantiate a List:

//Creating a List of type String using ArrayList

List<String> list=new ArrayList<String>();



//Creating a List of type Integer using ArrayList

List<Integer> list=new ArrayList<Integer>();



//Creating a List of type Book using ArrayList

List<Book> list=new ArrayList<Book>();



//Creating a List of type String using LinkedList

List<String> list=new LinkedList<String>();

Put simply, it is possible to generate a List of any kind by utilizing the ArrayList<T> and LinkedList<T> classes to define the type, with T representing the type.

Common List Operations

Below are several fundamental actions that can be executed on Java Lists.

1. Inserting Elements:
Example
Copy
list.add("Java");

list.add(1, "JavaScript");
Try it Yourself
2. Removing Elements:
Example
Copy
list.remove("Java");

list.remove(0);
Try it Yourself
3. Accessing Elements:
Example
Copy
String firstElement = list.get(0);

int index = list.indexOf("JavaScript");
Try it Yourself
4. Iterate Over List:
Example
Copy
for (String element : list) 

{

    System.out.println(element);

}
Try it Yourself

Java List Example

Let's examine a basic illustration of a List utilizing the ArrayList class as its implementation.

Example

import java.util.*;

public class Main{

public static void main(String args[]){

 //Creating a List

 List<String> list=new ArrayList<String>();

 //Adding elements in the List

 list.add("Mango");

 list.add("Apple");

 list.add("Banana");

 list.add("Grapes");

 //Iterating the List element using for-each loop

 for(String fruit:list)

  System.out.println(fruit);



}

}

Output:

Mango

Apple

Banana

Grapes

How to convert Array to List

A typical task in Java programming involves converting an array into a list. One way to achieve this is by iterating over the array and sequentially adding each element to the list using the List.add method. This method is commonly employed for this purpose. Additionally, there are alternative approaches that can be utilized, such as:

Method 1: Using Arrays.asList

Method 2: Using ArrayList Constructor

Example

import java.util.*;

public class Main{

public static void main(String args[]){

//Creating Array

String[] array={"Java","Python","PHP","C++"};

System.out.println("Printing Array: "+Arrays.toString(array));

//Converting Array to List

List<String> list=new ArrayList<String>();

for(String lang:array){

list.add(lang);

}

System.out.println("Printing List: "+list);



}

}

Output:

Printing Array: [Java, Python, PHP, C++]

Printing List: [Java, Python, PHP, C++]

How to convert List to Array

To transform a List into an Array, we can utilize the List.toArray method. Below is a straightforward illustration demonstrating how to convert elements from a list into an array.

Example

import java.util.*;

public class Main{

public static void main(String args[]){

 List<String> fruitList = new ArrayList<>();  

 fruitList.add("Mango");  

 fruitList.add("Banana");  

 fruitList.add("Apple");  

 fruitList.add("Strawberry");  

 //Converting ArrayList to Array

 String[] array = fruitList.toArray(new String[fruitList.size()]);  

 System.out.println("Printing Array: "+Arrays.toString(array));

 System.out.println("Printing List: "+fruitList);

}

}

Output:

Printing Array: [Mango, Banana, Apple, Strawberry]

Printing List: [Mango, Banana, Apple, Strawberry]

Get and Set Element in List

The get function retrieves the item located at the specified index, while the set function modifies or substitutes the item.

Example

import java.util.*;

public class Main{

 public static void main(String args[]){

 //Creating a List

 List<String> list=new ArrayList<String>();

 //Adding elements in the List

 list.add("Mango");

 list.add("Apple");

 list.add("Banana");

 list.add("Grapes");

 //accessing the element  

 System.out.println("Returning element: "+list.get(1));//it will return the 2nd element, because index starts from 0

 //changing the element

 list.set(1,"Dates");

 //Iterating the List element using for-each loop

 for(String fruit:list)

  System.out.println(fruit);



 }

}

Output:

Returning element: Apple

Mango

Dates

Banana

Grapes

How to Sort a List?

To arrange a list in Java, you can utilize either the Collections.sort function or the List.sort function that was added in Java 8. Below are demonstrations for both methods:

Example

import java.util.*;

class Main{

 public static void main(String args[]){

  //Creating a list of fruits

  List<String> list1=new ArrayList<String>();

  list1.add("Mango");

  list1.add("Apple");

  list1.add("Banana");

  list1.add("Grapes");

  //Sorting the list

  Collections.sort(list1);

   //Traversing list through the for-each loop

  for(String fruit:list1)

    System.out.println(fruit);

    

 System.out.println("Sorting numbers...");

  //Creating a list of numbers

  List<Integer> list2=new ArrayList<Integer>();

  list2.add(21);

  list2.add(11);

  list2.add(51);

  list2.add(1);

  //Sorting the list

  Collections.sort(list2);

   //Traversing list through the for-each loop

  for(Integer number:list2)

    System.out.println(number);

 }

 

}

Output:

Apple

Banana

Grapes

Mango

Sorting numbers...

1

11

21

51

Java ListIterator Interface

The ListIterator Interface enables the traversal of elements in both backward and forward directions.

ListIterator Interface declaration

public interface ListIterator<E> extends Iterator<E>

Methods of Java ListIterator Interface

Example of ListIterator Interface

Example

import java.util.*;

public class Main{

public static void main(String args[]){

List<String> al=new ArrayList<String>();  

		al.add("Amit");  

		al.add("Vijay");  

		al.add("Kumar");  

		al.add(1,"Sachin");  

		ListIterator<String> itr=al.listIterator();  

		System.out.println("Traversing elements in forward direction");  

		while(itr.hasNext()){  

			

		System.out.println("index:"+itr.nextIndex()+" value:"+itr.next());  

		}  

		System.out.println("Traversing elements in backward direction");  

		while(itr.hasPrevious()){  

		

		System.out.println("index:"+itr.previousIndex()+" value:"+itr.previous());  

		}  

}

}

Output:

Traversing elements in forward direction

index:0 value:Amit

index:1 value:Sachin

index:2 value:Vijay

index:3 value:Kumar

Traversing elements in backward direction

index:3 value:Kumar

index:2 value:Vijay

index:1 value:Sachin

index:0 value:Amit

Example of List: Book

Let's consider an illustration of a list where we are including various books.

Example

import java.util.*;

class Book {

int id;

String name,author,publisher;

int quantity;

public Book(int id, String name, String author, String publisher, int quantity) {

	this.id = id;

	this.name = name;

	this.author = author;

	this.publisher = publisher;

	this.quantity = quantity;

}

}

public class Main {

public static void main(String[] args) {

	//Creating list of Books

	List<Book> list=new ArrayList<Book>();

	//Creating Books

	Book b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);

	Book b2=new Book(102,"Data Communications and Networking","Forouzan","Mc Graw Hill",4);

	Book b3=new Book(103,"Operating System","Galvin","Wiley",6);

	//Adding Books to list

	list.add(b1);

	list.add(b2);

	list.add(b3);

	//Traversing list

	for(Book b:list){

	System.out.println(b.id+" "+b.name+" "+b.author+" "+b.publisher+" "+b.quantity);

	}

}

}

Output:

101 Let us C Yashwant Kanetkar BPB 8

102 Data Communications and Networking Forouzan Mc Graw Hill 4

103 Operating System Galvin Wiley 6

Java List MCQ

1. Which of the following statements about the ListIterator interface in Java is true?

• ✅ It extends the List interface.
• ✅ It allows bidirectional traversal of elements in a list.
• ✅ It is implemented by the ArrayList class only.
• ✅ It is used to synchronize access to a list.

Explanation: The ListIterator interface provides methods for traversing a list in both forward and backward directions, allowing bidirectional access to list elements.

1. What is the difference between ArrayList and LinkedList in Java?

• ✅ ArrayList is synchronized while LinkedList is not.
• ✅ ArrayList stores elements in a contiguous memory block while LinkedList uses a doubly-linked list.
• ✅ ArrayList allows constant-time positional access while LinkedList does not.
• ✅ ArrayList is a resizable array implementation of the List interface while LinkedList is a doubly-linked list implementation.

Explanation: ArrayList internally uses a dynamic array to store elements, while LinkedList uses a doubly-linked list. This fundamental difference affects their performance characteristics and suitability for different scenarios.

1. What is the time complexity of the add(int index, E element) operation in ArrayList and LinkedList respectively?

• ✅ O(1) and O(n)
• ✅ O(n) and O(1)
• ✅ O(log n) and O(log n)
• ✅ O(n) and O(n)

Explanation: In ArrayList, inserting an element at a specific index requires shifting subsequent elements, resulting in a time complexity of O(n). In LinkedList, inserting an element at a specific index can be done in constant time (O(1)) by adjusting the pointers, as it involves traversing to the desired position.

1. What is the purpose of the replaceAll(UnaryOperator <E> operator) method in the List interface?

• ✅ It replaces all occurrences of a specific element in the list.
• ✅ It replaces all elements in the list with a new specified element.
• ✅ It applies the specified unary operator to each element in the list, replacing each element with the result of the operator.
• ✅ It removes all occurrences of a specific element from the list.

Explanation: The replaceAll method in the List interface applies the specified unary operator to each element in the list, replacing each element with the result of the operator.

1. Which method is used to obtain a portion of a list between two specified indices?

• ✅ slice(int fromIndex, int toIndex)
• ✅ portion(int fromIndex, int toIndex)
• ✅ subList(int fromIndex, int toIndex)
• ✅ range(int fromIndex, int toIndex)

The method subList(int fromIndex, int toIndex) in the List interface is utilized to retrieve a segment of a list starting from the designated fromIndex (inclusive) up to the toIndex (exclusive).