Point to Remember:

1. It preserves insertion order and duplicates are allowed.

2. It accepts different types of objects and null insertions.

3. Similar to ArrayList, it is growable in nature, meaning, its size can shrink or grow dynamically.

4. It is best choice when insertion and deletion operations are involved mostly.

5. It resembles doubly linked list data structure which provides flexibility to implement other algorithms and data structure such as Stack,Queue and more.

6. It has the worst performance in case of fetching or accessing an element from the list as it provides linear-time performance.

7. It implements Serializable and Clonable interface but not RandomAccess interface.

8. It is not thread-safe, which means that multiple threads cannot safely access and modify the list at the same time.

9. It becomes slower than other List implementations when it comes to traversing over elements.

Method of Linked List Class

Linked List implements List and Deque interface. Therefore, there are several methods implemented by this class.

Below are the methods inherited from Deque.

Below are the methods is from List interface.

Constructors of Linked List

There are two constructor present in Linked list class. These constructors are explained below :-

1) new LinkeList()

It is a default constructor that creates an empty linked list. Unlike ArrayList, it doesn’t have capacity issue.

Syntax:

LinkedList<T> l = new LinkeList<>() :

2) new LinkedList(Collection obj)

It creates a linked list instance, consisting elements of the given collection object.

LinkedList l = new LinkedList(Collection obJ);

Operations in LinkedList Class

1) Add an element

There are several methods provided by LinkedList class to add an element, such as add(), addFirst(),addList(),push(),offerFirst() and more.
Among all, add() and addAll() methods are most commonly used methods to perform add operation.

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list

// Adding elements to linked list

linkedList.add("Programmerbay");
linkedList.add("Example");

// Displaying elements of the list
System.out.println(linkedList);

// addAll method to add list of elements
linkedList.addAll(Arrays.asList("element1","element2"));
System.out.println(linkedList);

}
}

Output:

[Programmerbay, Example]
[Programmerbay, Example, element1, element2]

2) Replace an element

LinkedList supports index based access which provides it the capability to update or replace an element at given position .
set() method is used for the purpose. Below is the code example.

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list

// Adding elements to linked list

linkedList.add("Programmerbay");
linkedList.add("Example");

// Displaying elements of the list
System.out.println(linkedList);

// set method to replace an element with new one
linkedList.set(1,"Removed") ; // Example would be replaced with Removed

System.out.println(linkedList);

}
}

Output:

[Programmerbay, Example]
[Programmerbay, Removed]

3) Remove an element

Like several add() methods, LinkedList supports several methods to remove an element from a list i.e remove(),removeFirst(),removeLast() , pop() and more. The most commonly used methods are remove() and removeAll(). Below is a code example

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list

// Adding elements to linked list

linkedList.add("Programmerbay");
linkedList.add("Example");
linkedList.add("Test");


// Displaying elements of the list
System.out.println(linkedList);

// remove(element) method to remove the given element
linkedList.remove("Test"); // element Test would be removed

System.out.println(linkedList);


// remove(index) method to remove element from the given index

linkedList.remove(1); // element would be removed, sitting at 1st index which is example in this case
System.out.println(linkedList);
}
}

Output:

[Programmerbay, Example, Test]
[Programmerbay, Example]
[Programmerbay]

4) Traverse or iterate over elements

Like other implementation classes of List interface, elements of a linked list can also be traversed through various ways, iterator object and forEach are some of them.

With the help of iterator, we can traverse through all the elements in the given linked list. Also, enhanced for loop can also be used to loop through elements. Below are the code example.

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list

// Adding elements to linked list

linkedList.add("Programmerbay");
linkedList.add("Example");
linkedList.add("Test");

// traversing element using iterator object
System.out.println("Traversing using iterator :: ");

Iterator iterator = linkedList.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

// traversing element using for each method
System.out.println("Traversing using for each :: ");
for (String str:
linkedList) {
System.out.println(str);
}


}
}

Output:

Traversing using iterator ::
Programmerbay
Example
Test
Traversing using for each ::
Programmerbay
Example
Test

5) Converting List to Array

toArray() method provides the capability to convert a given linked list to array of objects. Below is the code example.

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list
linkedList.add("Programmerbay");

System.out.println("List view :: "+ linkedList);
Object[] array = linkedList.toArray();

System.out.println("Array view :: ");
for (Object obj:
array) {
System.out.print(obj);
}
}
}

Output:

List view :: [Programmerbay]
Array view :: 
Programmerbay