In this article, We will come to know about a data structure called “Linked List” and its various in-built function in Java. Before moving directly towards inbuilt function let us take a small introduction to Linked List and its types.
What is a Linked List in Java?
A Linked List is a linear data structure, Which stores objects at non – continuous locations in heap memory. Objects are called Node.
Each Node contains two things one is Data and the other is a pointer. As these objects are at non-continuous locations, therefore, Each Node is connected to its next Node via the next pointer(called references in Java), Which points to the storage location of the next Node. For example and more see the image below.
Types of Linked Lists
Linked Lists are divided into the below 4 types based on their different properties :
Singly Linked List
That type of Linked List, Which contains the data part and next pointer in each Node is called a Singly Linked List. Traversal in this type of Linked List is uni-directional Because you can only in one direction with help of the next pointer.
The first node of the list is called as Head. The next pointer of the last node is NULL, Because the List ends here, Formally no further nodes after the last node.
The below image is a visual explanation of the Singly Linked List.
Doubly Linked List
A Doubly Linked List is a type of Linked List in which each Node contains data, next and previous pointer. Traversal is bi-directional because you can go from the current node to its next node via the next pointer and the previous as well from the previous pointer of the current node.
The previous pointer of the Head and the next pointer of the last Node are NULL. See the image below for a clear understanding of the structure.
Circular Linked List
Circular Linked List is a type of Linked List in which the Last Node’s next pointer indicates the storage location of the First Node. Formally, Circular Linked List has no start and end. The below image is a visualization example of a Circular Linked List.
Doubly Circular Linked List
Doubly Circular Linked List is a more optimized version of Simple Circular Linked List. Each Node contains data, next and prev pointer.
The next pointer of the Last node makes the reference to the First Node via the next pointer, While the prev pointer of the First node makes a reference to the Last Node.
So far till now, We know about the structure and types of Linked Lists. Now we will discuss some in-built methods for each type of linked list.
In-Built Methods of Linked List
To create an empty Singly Linked List we have to initialize an object of a linked List using the constructor LinkedList(). Below is the implementation of the code for creating an empty Linked List as an instance name list.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
System.out.println(list);
}
}
Output :
As we can see that we successfully created the Linked List of Integer data type by using the LinkedList() constructor.
As there is no element present in the list, Therefore the list in the output is empty.
Add() Method in Linked List
This method is used to insert the element at the end position of the list. Formally, appends the argument e of E data type in the list.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
System.out.println("5 added in the list");
list.add(7);
System.out.println("7 append in the list");
System.out.println(list);
}
}
Output :
We can see that 7 is appended after element 5 in the list.
Add Element at Specific Position in Linked List
This method is used to insert an element at the specified position in the Linked List.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(7);
System.out.println("List before adding 2 : "+list);
list.add(1,2);
System.out.println("2 inserted at index 1");
System.out.println("List after adding 2 : "+list);
}
}
Output :
In the output, we can see that 2 is inserted at the index 1, by using add(int index, element) method.
Add Collection to the Linked List
This method is used to append all the elements of the passed collection as an argument in the addAll() method of the E data type. Formally, We can append all the elements of the second list into the first list.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list_1 = new LinkedList<>();
list_1.add(1);
list_1.add(2);
System.out.println("List 1 : "+list_1);
LinkedList<Integer> list_2 = new LinkedList<>();
list_2.add(3);
list_2.add(4);
System.out.println("List 2 : "+list_2);
//Adding all elements of list_2 into list_1 by using addAll() method
list_1.addAll(list_2);
System.out.println("list_1 after adding all elements of list_2 : "+list_1);
}
}
Output :
We can see in the output that all the elements of list_2 are appended in the list_1 by using the allAll() method.
Add Collection at Specific Index in Linked List
This method is used to insert all the elements of the passed collection as an argument in the addAll() method of the E data type at the specified index. Formally, We can append all the elements of the second list into the first list.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list_1 = new LinkedList<>();
list_1.add(1);
list_1.add(2);
System.out.println("List 1 : "+list_1);
LinkedList<Integer> list_2 = new LinkedList<>();
list_2.add(3);
list_2.add(4);
System.out.println("List 2 : "+list_2);
//Adding all elements of list_2 into list_1 on index 1 by using addAll() method
list_1.addAll(1,list_2);
System.out.println("list_1 after adding all elements of list_2 on index 1 : "+list_1);
}
}
Output :
In the output, We can see that elements 3, and 4 of list_2 are inserted into list_1 from index 1.
Add Element at First Position in Linked List
AddFirst(E e) method is used to add element e of the E data type at the Head(very First element) of the list.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list_1 = new LinkedList<>();
list_1.add(50);
list_1.add(46);
System.out.println("list_1 : "+list_1);
//Adding elements 60 at first index of list by using addFirst() method
list_1.addFirst(60);
System.out.println("list_1 after adding 60 at Head of the list 1 : "+list_1);
}
}
Output :
Element 60 is added at the Head of list_1 using the addFirst() method.
Add Element at Last Position in Linked List
addLast(E e) method is used to insert an element at the last position of the list.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list_1 = new LinkedList<>();
list_1.add(50);
list_1.add(46);
System.out.println("list_1 : "+list_1);
//Adding elements 60 at last position of list by using addLast() method
list_1.addLast(60);
System.out.println("list_1 after adding 60 at last position of the list 1 : "+list_1);
}
}
Output :
Element 60 is added at the last position of the list by using the addLast() method.
Find the Size of the Linked List
size() method that returns the current size of the List.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(50);
list.add(46);
System.out.println("size of the list is : "+list.size());
}
}
Output :
In the output, it can be seen that size of the list is 3.
Remove Elements from the Linked List
the clear() method is used to remove all the elements present in the list currently.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(50);
list.add(46);
System.out.println("list : "+list);
list.clear();
System.out.println("list after using clear() method : "+list);
}
}
Output :
Clone Linked List Elements
Object cloning refers to the creation of an exact copy of an object. It creates a new instance of the class of the current object and initializes all its fields with exactly the contents of the corresponding fields of this object.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list_1 = new LinkedList<>();
list_1.add(50);
list_1.add(46);
LinkedList<Integer> list_2 = (LinkedList<Integer>) list_1.clone();
System.out.println("Copied elements in list_2 from list_1 : "+list_2);
}
}
Output :
Check Existing Elements in Linked List
contains(E e) method returns true if the element is present in the list else returns false.
Code :
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(6);
System.out.println("List contains 6 : "+list.contains(6));
System.out.println("List contains 8 : "+list.contains(8));
}
}
Output :
Find Elements in Linked List
get(int index) method is used to get elements at the specified index in the list, without removing it.
Code :
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(6);
list.add(1);
list.add(10);
list.add(2);
System.out.println(list);
System.out.println("Element present at index 2 : "+list.get(2));
}
}
Output :
Find the first or Last Elements in Linked List
getFirst() and getLast() : net first() and getLast() methods are used to get elements at First and Last position in the list respectively.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(6);
list.add(1);
list.add(10);
list.add(2);
System.out.println(list);
System.out.println("First element of the list : "+list.getFirst());
System.out.println("Last element of the list : "+list.getLast());
}
}
Output :
Find the index of the elements in the Linked List
indexOf(E e) and lastIndexOf(E e) : IndexOf(E e) and lastIndexOf(E e) are used to get index of first occurrence and last occurrence of an element e of data type E respectively.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(1);
list.add(2);
list.add(1);
list.add(9);
list.add(1);
System.out.println(list);
System.out.println("First index of element 1 : "+list.indexOf(1));
System.out.println("Last index of element 1 : "+list.lastIndexOf(1));
}
}
Output :
Find the First Element in Linked List
element() and peek(): Both methods return the element present at the head of the list, without removing it.
Code :
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(1);
list.add(2);
list.add(1);
list.add(9);
list.add(1);
System.out.println(list);
System.out.println("Head element using peek() method : "+list.peek());
System.out.println("Head element using element() method : "+list.element());
}
}
Output :
Remove Elements from the Linked List in Java
remove(), removeFirst() and removeLast() : Both the methods remove(), removeFirst() removes the element present at head of the list, While removeLast() removes the element present at last position in the list.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(1);
list.add(2);
list.add(1);
list.add(9);
list.add(1);
System.out.println(list);
System.out.println("Removing 5 at head by remove() function : "+list.remove());
System.out.println(list);
System.out.println("Removing 1 at head by removeFirst() function : "+list.removeFirst());
System.out.println(list);
System.out.println("Removing 1 at last position by removeLast() function "+list.removeLast());
System.out.println(list);
}
}
Output :
Remove Elements from Specific Index from the Linked List in Java
remove(int index) and remove(E e): remove(int index) removes the element at a specified position of the list. On the contrary, remove(E e) removes the first occurrence of the element e.
Code :
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(1);
list.add(2);
list.add(1);
list.add(9);
list.add(1);
System.out.println(list);
System.out.println("Removing element 2 present at index 2");
list.remove(2);
System.out.println(list);
System.out.println("Removing element 1 : "+list.remove(1));
System.out.println(list);
}
}
Output :
removeFirstOccurrence(E e) and removeLastOccurrence(E e): Both methods remove the first and last occurrence of an element in the list respectively.
//{ Driver Code Startspackage newPackage;
package newPackage;
import java.util.*;
import java.io.*;
import java.lang.*;
class BeeTechnical
{
public static void main(String args[])
{
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(1);
list.add(2);
list.add(1);
list.add(9);
list.add(1);
System.out.println(list);
System.out.println("Removing First occurrence of 1");
list.removeFirstOccurrence(1);
System.out.println(list);
System.out.println("Removing Last occurrence of 1");
list.removeLastOccurrence(1);
System.out.println(list);
}
}
Output :
Conclusion
In the article above we came to know what is Linked List its visual structure, and its types, and explore various in-built methods in java.util.LinkedList class along with codes and their output.
Comments are closed.