ArrayList and LinkedList in Java

        

          

            

              
              

          
 
          

          
          

          

              

                  
              

          






Introduction to ArrayList and LinkedList in Java


Introduction to Java Collections Framework



The Java Collections Framework is a unified architecture for representing and manipulating collections of objects. It provides a variety of interfaces and classes that can be used to store, retrieve, and manipulate collections in an efficient and flexible way.



The Collections Framework is divided into two main parts:



    
  
  • Interfaces: The Collections Framework defines a number of interfaces that represent different types of collections, such as lists, sets, and maps. These interfaces define the operations that can be performed on each type of collection.
    • 
  
  • Classes: The Collections Framework provides a number of classes that implement the collection interfaces. These classes provide concrete implementations of the various collection types.
    • 




The Collections Framework is a powerful tool that can be used to simplify and streamline the development of Java applications. By using the Collections Framework, developers can avoid having to implement their own data structures and algorithms for managing collections.



Here are some of the benefits of using the Java Collections Framework:



    
  
  • Reusability:The Collections Framework provides a number of reusable classes and interfaces that can be used to store and manipulate collections of objects. This can save developers time and effort, and it can also make code more maintainable.
    • 
  
  • Efficiency: The Collections Framework classes are implemented in a highly efficient manner. This can help to improve the performance of Java applications.
    • 
  
  • Flexibility:The Collections Framework provides a variety of collection types and interfaces, which gives developers the flexibility to choose the right collection for their needs.
    • 
  
  • Type safety:The Collections Framework uses generics to ensure type safety. This can help to prevent type errors and make code more reliable.
    • 




If you are developing Java applications, I encourage you to learn more about the Java Collections Framework. It is a powerful tool that can help you to write better code.



Here are some examples of how the Java Collections Framework can be used:



    
  
  • To store a list of items in a shopping cart.
    • 
  
  • To store a set of unique values, such as the unique elements of a list.
    • 
  
  • To store a mapping of keys to values, such as a dictionary.
    • 
  
  • To store a queue of items to be processed in order.
    • 
  
  • To store a stack of items to be processed in reverse order.
    • 




The Java Collections Framework is a versatile tool that can be used to solve a variety of problems. By understanding the basics of the Collections Framework, you can write more efficient and reliable Java code.



Introduction to Arraylist in Java


An ArrayList in Java is a resizable array, which means that it can grow and shrink as needed. This is in contrast to a traditional Java array, which has a fixed size. ArrayLists are implemented using a dynamic array, which is an array that can be resized at runtime.



To create a new ArrayList, you can use the following constructor:




ArrayList arrayList = new ArrayList<>();




The `T` parameter specifies the type of data that the ArrayList will store. For example, if you want to store a list of integers, you would use the following constructor:




ArrayList integerArrayList = new ArrayList<>();




Once you have created an ArrayList, you can add and remove elements from it using the following methods:




// Adds an element to the end of the ArrayList.
arrayList.add(element);





// Removes an element from the ArrayList at the specified index.
arrayList.remove(index);




You can also get an element from the ArrayList at a specified index using the following method:




// Returns the element at the specified index in the ArrayList.
T element = arrayList.get(index);




ArrayLists are a very versatile data structure and can be used to store a variety of different types of data. They are also very efficient, as they can grow and shrink as needed.



Methods of an ArrayList



  
    

      Method
      Description
    

  
  
    

      add(element)
      Adds an element to the end of the ArrayList.
    

    

      add(index, element)
      Adds an element at the specified index in the ArrayList.
    

    

      addAll(collection)
      Adds all of the elements of the specified collection to the ArrayList.
    

    

      addAll(index, collection)
      Adds all of the elements of the specified collection to the ArrayList at the specified index.
    

    

      clear()
      Removes all of the elements from the ArrayList.
    

    

      contains(element)
      Returns `true` if the ArrayList contains the specified element, otherwise `false`.
    

    

      containsAll(collection)
      Returns `true` if the ArrayList contains all of the elements of the specified collection, otherwise `false`.
    

    

      get(index)
      Returns the element at the specified index in the ArrayList.
    

    

      indexOf(element)
      Returns the index of the first occurrence of the specified element in the ArrayList, or `-1` if the element is not found.
    

    

      isEmpty()
      Returns `true` if the ArrayList is empty, otherwise `false`.
    

    

      lastIndexOf(element)
      Returns the index of the last occurrence of the specified element in the ArrayList, or `-1` if the element is not found.
    

    

      remove(element)
      Removes the first occurrence of the specified element from the ArrayList.
    

    

      remove(index)
      Removes the element at the specified index from the ArrayList.
    

    

      removeAll(collection)
      Removes all of the elements of the specified collection from the ArrayList.
    

    

      retainAll(collection)
      Removes all of the elements from the ArrayList that are not also in the specified collection.
    

    

      set(index, element)
      Sets the element at the specified index in the ArrayList to the specified element.
    

    

      size()
      Returns the size of the ArrayList.
    

    

      toArray()
      Returns an array containing all of the elements of the ArrayList.
    

  




Here are some of the benefits of using ArrayLists in Java:



    
  
  • Reusability:ArrayLists can be reused to store different types of data without having to duplicate code.
    • 
  
  • Flexibility:ArrayLists can grow and shrink as needed, making them a flexible data structure for storing collections of data.
    • 
  
  • Efficiency: ArrayLists are implemented using a dynamic array, which is an efficient way to store collections of data.
    • 
  
  • Ease of use:ArrayLists are easy to use and provide a simple interface for adding, removing, and accessing elements.
    • 




Overall, ArrayLists are a powerful and versatile data structure that can be used to improve the quality and efficiency of Java code.



Introduction to LinkedList in Java


A LinkedList in Java is a dynamic data structure that consists of a series of nodes, each of which contains a data element and a reference to the next node in the list. LinkedLists are implemented in a way that allows them to grow and shrink as needed, making them a flexible and efficient data structure for storing collections of data.


  
To create a new LinkedList in Java, you can use the following constructor:


  

  LinkedList linkedList = new LinkedList<>();
  



  
The `T` parameter specifies the type of data that the LinkedList will store. For example, if you want to store a list of integers, you would use the following constructor:


  

  LinkedList integerLinkedList = new LinkedList<>();
  


  
Once you have created a LinkedList, you can add and remove elements from it using the following methods:


  

  // Adds an element to the end of the LinkedList.
  linkedList.add(element);

  // Removes an element from the LinkedList at the specified index.
  linkedList.remove(index);



  
You can also get an element from the LinkedList at a specified index using the following method:


  

  // Returns the element at the specified index in the LinkedList.
  T element = linkedList.get(index);
  



Methods of LinkedList



  
    

      Method
      Description
    

  
  
    

      add(element)
      Adds an element to the end of the LinkedList.
    

    

      add(index, element)
      Adds an element at the specified index in the LinkedList.
    

    

      addAll(collection)
      Adds all of the elements of the specified collection to the LinkedList.
    

    

      addAll(index, collection)
      Adds all of the elements of the specified collection to the LinkedList at the specified index.
    

    

      clear()
      Removes all of the elements from the LinkedList.
    

    

      contains(element)
      Returns `true` if the LinkedList contains the specified element, otherwise `false`.
    

    

      containsAll(collection)
      Returns `true` if the LinkedList contains all of the elements of the specified collection, otherwise `false`.
    

    

      get(index)
      Returns the element at the specified index in the LinkedList.
    

    

      indexOf(element)
      Returns the index of the first occurrence of the specified element in the LinkedList, or `-1` if the element is not found.
    

    

      isEmpty()
      Returns `true` if the LinkedList is empty, otherwise `false`.
    

    

      lastIndexOf(element)
      Returns the index of the last occurrence of the specified element in the LinkedList, or `-1` if the element is not found.
    

    

      remove(element)
      Removes the first occurrence of the specified element from the LinkedList.
    

    

      remove(index)
      Removes the element at the specified index from the LinkedList.
    

    

      removeAll(collection)
      Removes all of the elements of the specified collection from the LinkedList.
    

    

      retainAll(collection)
      Removes all of the elements from the LinkedList that are not also in the specified collection.
    

    

      set(index, element)
      Sets the element at the specified index in the LinkedList to the specified element.
    

    

      size()
      Returns the size of the LinkedList.
    

    

      toArray()
      Returns an array containing all of the elements of the LinkedList.
    

  




  
Here are some of the benefits of using LinkedLists in Java:


  
    
    
  • Reusability:LinkedLists can be reused to store different types of data without having to duplicate code.
    • 
    
  • Flexibility:LinkedLists can grow and shrink as needed, making them a flexible data structure for storing collections of data.
    • 
    
  • Efficiency: LinkedLists are implemented in a way that allows them to be efficient for adding and removing elements from the list.
    • 
    
  • Ease of use:LinkedLists are easy to use and provide a simple interface for adding, removing, and accessing elements.
    • 
  


  
Here are some examples of how LinkedLists can be used in Java:


  
    
    
  • To implement a stack or queue.
    • 
    
  • To implement a doubly-linked list, which allows for efficient traversal of the list in both directions.
    • 
    
  • To implement a hash table, which is a data structure for storing key-value pairs.
    • 
    
  • To implement a linked list of nodes in a graph or tree data structure.
    • 
  


  
LinkedLists are a powerful and versatile data structure that can be used to solve a variety of problems in Java. By understanding the basics of LinkedLists, you can write more efficient and reliable Java code.







Exercises


Code for creating and adding elements to an Arraylist in Java



  package sampleproject;
  import java.util.*;
  import java.io.*;
  public class democlass{	
    
    public static void main(String[] args) throws InterruptedException{
      
      ArrayList<String> name = new ArrayList<String>();
      name.add("satish");
      name.add("ram");
      name.add("tom");
      System.out.println(name);	
    }
  } 




Code for Inserting an Element in a specific index in an ArrayList in Java



package sampleproject;
import java.util.*;
import java.io.*;
public class democlass{	
  
  public static void main(String[] args) throws InterruptedException{
    
    ArrayList<String> name = new ArrayList<String>();
    name.add("satish");
    name.add("ram");
    name.add("tom");
    name.add(1, "test");
    System.out.println(name);
  }
}
 




Code for removing an element using a specific index in an ArrayList in Java



package sampleproject;
import java.util.*;
import java.io.*;
public class democlass{	
  
  public static void main(String[] args) throws InterruptedException{
    
    ArrayList<String> name = new ArrayList<String>();
    name.add("satish");
    name.add("ram");
    name.add("ram");
    name.remove(1);
    System.out.println(name);
  }
} 




Code for removing all elements from an ArrayList



  package sampleproject;
  import java.util.*;
  import java.io.*;
  public class democlass{	
    
    public static void main(String[] args) throws InterruptedException{
      
      ArrayList<String> name = new ArrayList<String>();
      name.add("satish");
      name.add("ram");
      name.add("ram");
      name.clear();
      System.out.println(name);	
    }
  }
 




Code for replacing an element inside an arraylist using the index in Java



package sampleproject;
import java.util.*;
import java.io.*;
public class democlass{	
  
  public static void main(String[] args) throws InterruptedException{
    
    ArrayList<String> name = new ArrayList<String>();
    name.add("satish");
    name.add("ram");
    name.add("jeff");
    name.set(0, "tom");
    System.out.println(name);
  }
}
 




Code for searching the Arraylist for a specific value.



  package sampleproject;
  import java.util.*;
  import java.io.*;
  public class democlass{	
    
    public static void main(String[] args) throws InterruptedException{
      
      ArrayList<String> name = new ArrayList<String>();
      name.add("satish");
      name.add("ram");
      name.add("jeff");
      if(name.contains("ram"))
      {
        System.out.println("its a good collection");
      }
    }
  } 




Searching an ArrayList using the lastIndexOf method in Java.



package sampleproject;
import java.util.*;
import java.io.*;
public class democlass{	
  
  public static void main(String[] args) throws InterruptedException{
    
    ArrayList<String> name = new ArrayList<String>();
    name.add("satish");
    name.add("ram");
    name.add("jeff");
    if(name.lastIndexOf("satish")>=0)
    {
      System.out.println("The element is found");
    }
  }
} 




Code for copying one ArrayList to another



  package sampleproject;
  import java.util.*;
  import java.io.*;
  public class democlass{	
    
    public static void main(String[] args) throws InterruptedException{
      
      ArrayList<String> name = new ArrayList<String>();
      name.add("satish");
      name.add("ram");
      name.add("jeff");
      ArrayList name1 = (ArrayList) name.clone();
      for(int i=0;i<name1.size();i++)
      {
        System.out.println(name1.get(i));
      }
    }
  } 




Code for traversing an ArrayList using an iteraror



package sampleproject;
import java.util.*;
import java.io.*;
public class democlass{	
  
  public static void main(String[] args) throws InterruptedException{
    
    ArrayList<String> name = new ArrayList<String>();
    name.add("satish");
    name.add("ram");
    name.add("jeff");
    Iterator itr = name.iterator();
    while(itr.hasNext())
    {
      System.out.println(itr.next());
    }
  }
}      
 




Code for traversing an arraylist in the reverse using the listiterator.



  package sampleproject;
  import java.util.*;
  import java.io.*;
  public class democlass{	
    
    public static void main(String[] args) throws InterruptedException{
      
      ArrayList<String> name = new ArrayList<String>();
      name.add("satish");
      name.add("ram");
      name.add("jeff");
      ListIterator<String> itr = name.listIterator(name.size());
      while(itr.hasPrevious())
      {
        System.out.println(itr.previous());
      }
    }
  }   
 




Code for demo on retainALL and removeALL methods



  package sampleproject;
  import java.util.*;
  import java.io.*;
  public class democlass{	
    
    public static void main(String[] args) throws InterruptedException{
      ArrayList<String> name1 = new ArrayList<String>();
      name1.add("satish");
      name1.add("ram");
      ArrayList<String> name2 = new ArrayList<String>();
      name2.add("tom");
      name2.add("jeff");
      name1.addAll(name2); //adds all the elements in name2 to name
      //name1.retainAll(name2); //removes all elements from name except added from name2
      //name1.removeAll(name2); //removes all elements added from name2
      Iterator itr = name1.iterator();
      while(itr.hasNext())
      {
        System.out.println(itr.next());
      } 
    }
  } 




Code for creating an ArrayList of Student Objects



  package sampleproject;
  import java.util.*;
  import java.io.*;
  public class democlass{	
    
    public static void main(String[] args) throws InterruptedException{
      
      students s1 = new students("satish","123");
      students s2 = new students("ramesh","124");
      ArrayList<students> javaclass = new ArrayList<students>();
      javaclass.add(s1);
      javaclass.add(s2);
      Iterator<students> itr = javaclass.iterator();
      while(itr.hasNext())
      {
        students s = itr.next();
        System.out.println(s.name+s.regno);
      }
    }
  }	
  
  class students
  {
    String name;
    String regno;
    public students(String name, String regno) {
        this.name = name;
      this.regno = regno;
    }
    public void display() {
      System.out.println(name+regno);
    }
  } 




Code for creating a LinkedList and traversing the list in Java



import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Scanner;
public class Satish20BCE001{
  
  public static void main(String[] args) throws IOException{
    
        LinkedList<String> name = new LinkedList<String>();
        name.add("satish");
        name.add("ram");
        name.add("tom");
        ListIterator<String> itr = name.listIterator();
        while(itr.hasNext())
        {
          System.out.println(itr.next());
        }
      
    }	
}
 




Code for traversing the LinkedList from the reverse using a ListIterator.



  import java.io.*;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.ListIterator;
  import java.util.Scanner;
  public class Satish20BCE001{
    
    public static void main(String[] args) throws IOException{
      
          LinkedList<String> name = new LinkedList<String>();
          name.add("satish");
          name.add("ram");
          name.add("tom");
          ListIterator<String> itr = name.listIterator(name.size());
          while(itr.hasPrevious())
          {
            System.out.println(itr.previous());
          }
        
      }	
  }
  
  // or you can also use the code given below
  
  // traversing in the reverse using descending iterator 
  
  import java.io.*;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.ListIterator;
  import java.util.Scanner;
  public class Satish20BCE001{
    
    public static void main(String[] args) throws IOException{
      
          LinkedList<String> name = new LinkedList<>();
          name.add("satish");
          name.add("ram");
          name.add("tom");
          Iterator<String> itr = name.descendingIterator();
        while(itr.hasNext())
        {
          System.out.println(itr.next());
        }
        
      }	
  }  




Create a linkedlist of student objects. 
  Traverse the linkedlist in the reverse and print only objects that 
  has the registration numbers containing 12bce.



  import java.io.*;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.ListIterator;
  import java.util.Scanner;
  public class Satish20BCE001{
    
    public static void main(String[] args) throws IOException{
      
        students satish = new students("satish","12bce"); 
        students ram = new students("ram","13bce");
        boolean found = false;
        LinkedList<students> name = new LinkedList<>();
        name.add(satish);
        name.add(ram);
        Iterator<students> itr = name.descendingIterator();
        while(itr.hasNext())
        {
          students s = itr.next();
          if(s.regno.contains("12bce"))
          {
            System.out.println("Student is found");
            found=true;
            break;
          }
        }
        
        if(!found)
        {
          System.out.println("Student not found");
        }
        
      }	
  }
  
  class students
  {
    String name;
    String regno;
    public students(String name, String regno) {
        this.name = name;
      this.regno = regno;
    }
    public void display() {
      System.out.println(name+regno);
    }
  }