Java List

August 4, 2023

What is Java List?

In Java, a List is an interface that represents an ordered collection of elements that allows duplicates. It is a part of the Java Collection Framework and is implemented by various classes such as ArrayList, LinkedList, Vector, etc.
The List interface provides various methods to add, remove, retrieve, and manipulate elements in the collection. Some of the commonly used methods of the List interface include add(), remove(), get(), set(), size(), and indexOf().
To understand the Java List, Read the Complete Article.

Classes that Implement List:

In Java, the List interface is implemented by several classes, each with its own characteristics and advantages.

ArrayList: It is an implementation of List that uses an array to store the elements. It is a dynamic array, which means that it can grow or shrink dynamically based on the number of elements.
LinkedList: It is an implementation of List that uses a doubly-linked list to store the elements. It provides fast insertion and deletion at the beginning or end of the list but slower random access.
Vector: It is similar to ArrayList but is synchronized, which means that it is thread-safe. It is a legacy class that was introduced in JDK 1.0 and is not recommended for new development.
Stack: It is a subclass of Vector and provides a stack data structure, where the elements are added and removed in a Last-In-First-Out (LIFO) manner.

These are some of the commonly used classes that implement the List interface in Java.

How to use list ?

Import the required List class: Depending on the List implementation you want to use, you need to import the corresponding class.

Create an instance of the List: You can create an instance of the List using the constructor of the List implementation class.

Add elements to the List: You can add elements to the List using the add() method.

Retrieve elements from the List: You can retrieve elements from the List using the get() method.

Modify elements in the List: You can modify elements in the List using the set() method.

Remove elements from the List: You can remove elements from the List using the remove() method.

Iterate over the List: You can iterate over the elements of the List using a for loop or a foreach loop.

These are the basic steps to use a List in Java. Depending on the requirements of your application, you may need to use additional methods or operations to manipulate the List.

Methods of lists:

Here are some of the commonly used methods of the List interface:

add(E element): Adds the specified element to the end of the List.

add(int index, E element): Inserts the specified element at the specified position in the List.

get(int index): Returns the element at the specified position in the List.

set(int index, E element): Replaces the element at the specified position in the List with the specified element.

remove(Object o): Removes the first occurrence of the specified element from the List.

remove(int index): Removes the element at the specified position in the List.

size(): Returns the number of elements in the List.

indexOf(Object o): Returns the index of the first occurrence of the specified element in the List.

clear(): Removes all the elements from the List.

isEmpty(): Returns true if the List contains no elements.

contains(Object o): Returns true if the List contains the specified element.

addAll(Collection c): Adds all the elements of the specified collection to the end of the List.

addAll(int index, Collection c): Inserts all the elements of the specified collection into the List, starting at the specified position.

subList(int fromIndex, int toIndex): Returns a view of the portion of the List between the specified fromIndex, inclusive, and toIndex, exclusive.

Introduction to java

static variable in java

If statement in Java

Switch Statement in Java

Abstraction in Java

Let’s look at the Java getOrDefault() Method to perform certain operations.

Example 1:Java Program to Implementing the ArrayList Class

Run

import java.util.ArrayList;
import java.util.List;

public class Main
{
  public static void main (String[]args)
  {
    // Create an instance of ArrayList
    List < String > myList = new ArrayList < String > ();

    // Add elements to the ArrayList
    myList.add ("RealMadrid");
    myList.add ("Mancity");
    myList.add ("Man utd");

    // Print the ArrayList
    System.out.println ("My List: " + myList);

    // Modify an element in the ArrayList
    myList.set (1, "Barca");

    // Remove an element from the ArrayList
    myList.remove ("Man utd");

    // Print the ArrayList again
    System.out.println ("My List after modification: " + myList);

    // Retrieve an element from the ArrayList
    String firstElement = myList.get (0);
      System.out.println ("First element of the List: " + firstElement);

    // Iterate over the elements of the ArrayList
    for (String element:myList)
      {
	System.out.println (element);
      }

    // Get the size of the ArrayList
    int size = myList.size ();
    System.out.println ("Size of the List: " + size);
  }
}

Output

My List: [RealMadrid, Mancity, Man utd]
My List after modification: [RealMadrid, Barca]
First element of the List: RealMadrid
RealMadrid
Barca
Size of the List: 2

Explanation:

This is the same code as the one I provided earlier as an example Java program to implement the ArrayList class.

It demonstrates how to use the ArrayList class in Java to add, modify, remove, retrieve, iterate over, and get the size of elements in an ArrayList.

To summarize, the ArrayList class is an implementation of the List interface in Java, and it uses an array to store elements.

It provides dynamic resizing, fast random access to elements by their index position, and support for adding, modifying, and removing elements.

Example 2 : Java Program to Implementing the LinkedList Class

Run

import java.util.LinkedList;
import java.util.List;

public class Main
{
  public static void main (String[]args)
  {
    // Create an instance of LinkedList
    List < String > myList = new LinkedList < String > ();

    // Add elements to the LinkedList
    myList.add ("Samsung");
    myList.add ("Nokia");
    myList.add ("MI");

    // Print the LinkedList
    System.out.println ("My List: " + myList);

    // Modify an element in the LinkedList
    myList.set (1, "Motorola");

    // Remove an element from the LinkedList
    myList.remove ("MI");

    // Print the LinkedList again
    System.out.println ("My List after modification: " + myList);

    // Retrieve an element from the LinkedList
    String firstElement = myList.get (0);
      System.out.println ("First element of the List: " + firstElement);

    // Iterate over the elements of the LinkedList
    for (String element:myList)
      {
	System.out.println (element);
      }

    // Get the size of the LinkedList
    int size = myList.size ();
    System.out.println ("Size of the List: " + size);
  }
}

Output

My List: [Samsung, Nokia, MI]
My List after modification: [Samsung, Motorola]
First element of the List: Samsung
Samsung
Motorola
Size of the List: 2

Explanation:

This program demonstrates how to use the LinkedList class in Java.

The LinkedList class is similar to the ArrayList class, but it uses a linked list data structure instead of an array to store elements.

The advantage of using a linked list is that it can be more efficient than an array when adding or removing elements from the middle of the list.

However, accessing elements by their index position can be slower compared to an array-based implementation.

In Java, List and Set are interfaces that define collections of objects. However, there are some key differences between them:

Order: A List maintains the order of elements in which they were inserted, whereas a Set does not guarantee any specific order of its elements.

Duplicates: A List can contain duplicate elements, whereas a Set cannot contain duplicate elements.

Retrieval: A List allows elements to be retrieved by their index position, whereas a Set does not provide a way to retrieve elements by their index position.

Performance: Depending on the implementation, some operations such as searching or removing an element can be faster in a Set compared to a List, because a Set uses a hash-based algorithm for storing elements and checking for duplicates.

Iterator: Iterating over the elements of a List is generally slower compared to a Set because it needs to maintain the order of the elements, whereas a Set can iterate over its elements more efficiently.

In general, you would use a List when you need to maintain the order of elements and allow duplicates, and you would use a Set when you need to ensure that there are no duplicates in the collection and order is not important. The choice between List and Set depends on the specific requirements of your application.

Prime Course Trailer

Related Banners

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription

Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others

Java List

What is Java List?

Classes that Implement List:

Let’s look at the Java getOrDefault() Method to perform certain operations.

Example 1:Java Program to Implementing the ArrayList Class

Output

Example 2 : Java Program to Implementing the LinkedList Class

Output

Prime Course Trailer

Related Banners

Get over 200+ course One Subscription

Checkout list of all the video courses in PrepInsta Prime Subscription

Checkout list of all the video courses in PrepInsta Prime Subscription