An Introduction to List in Java

public interface List<E> extends Collection<E>

Methods

Usage

int size()

It is used to return the total number of elements in the List.

void add(int index, Object obj)

It is used to insert the element or object at the specified index.

boolean add(Object obj)

This method is used to append the element at the end of the list.

boolean addAll(int index, Collection c)

This method is used to add all the elements of the collection c to the list on which this method is invoked. starting from the index mentioned in the parameter. It preserves all the elements in the list as elements. It only gets shifted and is not overwritten. And it returns true if there is any change, else it returns false.

boolean isEmpty()

It is used to check whether or not the list is empty.

Object get(int index)

This get method when invoked on a list returns the object/element at the index specified in the parameter.

int indexOf(Object obj)

This method returns the position/index of the first occurrence of the object specified in the parameter. If such an object is not present in the list, it returns -1.

int lastIndexOf(Object obj)

This method will return the index of the last occurrence of the object specified in the parameter or returns -1 if no such object is found.

boolean contains(Object obj)

This method will return true if the list contains the object specified in the parameter, else it will return false.

Object set(int index, Object obj)

This method will replace the object at the specified index in the list with the object specified in the parameter.

Object remove(int index)

This method removes the object at the specified index in the list, compacts the list, and returns the object deleted.

void clear()

This method removes all the elements or objects from the list.

boolean remove(Object obj)

This method removes the first occurrence of the object specified and returns true if the operation is successful, else false.

boolean retainAll(Collection<?> c)

This method retains only those elements in the list that are present in the specified collection.

ListIterator listIterator()

It returns an iterator that points towards the start of the list.

ListIterator listIterator(int index)

It returns an iterator that points towards the index specified in the parameter. 

List subList(int start, int end)

This method returns a portion of the list from the start index (inclusive) to the end index (exclusive).

Object[] toArray()

This method returns an array that contains all the elements of the list in the same order.

default void replaceAll(UnaryOperator<E> operator)

This method replaces all the elements/objects in the list by the result that’s returned after applying the operator on the element.

default void sort(Comparator<super E> c)

This method sorts the list based on the comparator that’s passed in the parameter.

import java.util.*; 
public class Hello {
      public static void main(String[] args) 
      { 
          //Implement ArrayList class using the myList.
          List<String> myList = new ArrayList<String>();
         
          //Add String objects to the list
          myList.add("Welcome ");
          myList.add("to "); 
          myList.add("Simplilearn"); 
          System.out.println(myList); 
      } 
  }  

  import java.util.*; 
  public class Hello {
          public static void main(String[] args) 
          { 
              ArrayList<Integer> l = new ArrayList<Integer>(); 
              l.add(1);
              l.add(2); 
              l.add(3); 
              System.out.println(l); 
          } 
      }  

List

ArrayList

It’s categorized as an interface.

It’s a class that implements the list interface.

The list interface extends the collection framework.

It extends the AbstractList class.

It allows faster object manipulation compared to ArrayList.

It’s slower than a list.

You can’t instantiate them.

It can be instantiated.

They are not dynamic.

We can expand them dynamically.

List <type> myArrayList= new ArrayList();   
List <type> myLinkedList = new LinkedList();   
List <type> myVector = new Vector();   
List <type> myStack = new Stack();

import java.util.*; 
public class Hello {
        public static void main(String[] args) 
        { 
            List<Integer> intList = new ArrayList<Integer>();
            System.out.println(intL); 
        } 
    }  

import java.util.*; 
public class Hello {
  public static void main(String[] args) 
      { 
          List<Integer> intList = new ArrayList<Integer>();
          intList.add(1);
          intList.add(3);
          intList.add(1, 2);
          System.out.println(intList); 
      } 
  }  

import java.util.*; 
public class Hello {
  public static void main(String[] args) 
      { 
          List<Integer> intList = new ArrayList<Integer>();
          intList.add(1);
          intList.add(3);
          intList.add(1, 2);
          intList.set(1, 58);
          System.out.println(intList); 
      } 
  }  

import java.util.*; 
public class Hello {
  public static void main(String[] args) 
      { 
          List<String> list = new ArrayList<String>();
          list.add("Welcome");
          list.add("to");
          list.add("Simplilearn");
          list.add("to");
          list.add("learn");
         
          //The list is ["Welcome", "to", "Simplilearn", "to", "learn"]

          list.remove("to");

          //The list is ["Welcome", "Simplilearn", "to", "learn"]

          list.remove(0);

          //The list is ["Simplilearn", "to", "learn"]

          System.out.println(list); 
      } 
  }  

import java.util.*; 
public class Hello {
  public static void main(String[] args) 
      { 
          List<String> list = new ArrayList<String>();
          list.add("Welcome");
          list.add("to");
          list.add("Simplilearn");
          list.add("to");
          list.add("learn");
         
          //Basic for loop
          for(int i=0; i<list.size(); i++){
              System.out.print(list.get(i) + " ");
          }
          System.out.println();
          //For-each loop
          for(String s:list){
              System.out.print(s + " ");
          }

      } 
  }  

import java.util.*; 
public class Hello {
  public static void main(String[] args) 
      { 
          String[] message = {"Welcome", "to", "Simplilearn"};
          List<String> messageList = Arrays.asList(message);
          System.out.println(messageList);

          //We can't do modifications such as remove, clear, etc. in this list.

          //Let's use for loop to copy the array elements to a new list.

          List<String> myMessage = new ArrayList<>();
          for(String s:messageList){
              myMessage.add(s);
          }
          System.out.println(myMessage);
          myMessage.clear();
      } 
  }  

import java.util.*; 
public class Hello {
  public static void main(String[] args) 
      { 
          String[] message = {"Welcome", "to", "Simplilearn"};

          List<String> myMessage = new ArrayList<>();
         
          Collections.addAll(myMessage, message);

          System.out.println(myMessage);

          myMessage.add("It's");
          myMessage.add("Awwsome");

          System.out.println(myMessage);

          myMessage.clear();
      } 
  }  

import java.util.*; 
public class Hello {
  public static void main(String[] args) 
      { 

          List<String> myMessage = new ArrayList<>();
         
          myMessage.add("Welcome");
          myMessage.add("to");
          myMessage.add("Simplilearn");

          System.out.println(myMessage);

          String[] messageArray = new String[myMessage.size()];
          messageArray = myMessage.toArray(messageArray);
         
          //toString method converts an array object to string
          System.out.println(Arrays.toString(messageArray));
     
      } 
  }