When discussing ArrayList and LinkedList, we know that they are two data structures. The two are used to store and manage object collections. They have varied advantages and disadvantages. They simplify tasks like sorting, searching, deleting, inserting, and manipulating while lowering the complexity of computational time and human labor.
We will talk about Java's LinkedList vs ArrayList in this article.
Here’s what we’ll cover:
- Understanding ArrayList in Java
- Understanding LinkedList in Java
- Key Differences Between ArrayList and LinkedList
- How Does ArrayList Work in Java?
- How Does LinkedList Work in Java?
- How to Insert Data in ArrayList?
- How to Insert Values in LinkedList?
- How to Delete Values in ArrayList
- How to Delete Values in LinkedList
- How To Choose Between ArrayList and LinkedList?
- Get Ready for Your Java Developer Interview
- FAQs About ArrayList vs. LinkedList in Java
Understanding ArrayList in Java
In Java, arrays are handy for storing data, but they come with a fixed size. To overcome this limitation, we have ArrayList, a dynamic array implementation in the Java Collections Framework.
Why ArrayList?
While arrays are easy to comprehend, ArrayList offers flexibility. It is part of the Java.util package and allows us to change the size dynamically while running an application, which makes it so helpful in situations where we need to add or remove elements regularly.
Key Features:
- Dynamic Resizing: ArrayList adjusts its size automatically when elements are added or removed—no need to worry about predefined sizes.
- Easy Manipulation: Adding or removing elements is a breeze with ArrayList. It's perfect for situations where the array size keeps changing.
Example in Action:
Let's look at a simple example to see how ArrayList works:
import java.util.ArrayList;
class Example {
public static void main(String[] args) {
// Creating an ArrayList of Integer type
ArrayList numbers = new ArrayList<>();
// Adding elements to the list
for (int i = 1; i <= 5; i++)
numbers.add(i);
// Printing the ArrayList
System.out.println(numbers);
// Removing an element at index 3
numbers.remove(3);
// Printing the ArrayList after removing the element
System.out.println(numbers);
}
}
Output:
[1, 2, 3, 4, 5][1, 2, 3, 5]
In this example, we create an ArrayList of integers, add elements through iteration Loop, and remove one element at position 3.
Understanding LinkedList in Java
If you need a dynamic solution to store data that is easily expandable or contractible in Java, LinkedList is just for you. Unlike arrays where everything is compacted, LinkedList keeps every bit of information in a different package named node. This article breaks down LinkedList's simple nature using an example.
LinkedList Basics:
- Node Setup: In a LinkedList, data isn't confined to one block of memory. Rather than having each one dwelling at a single address, the node has its home, speaking for a given piece of data that holds both the value itself and reference to adjacent nodes.
- Dynamic Operations: LinkedLists are great for scenarios where you frequently add or remove data. They're like dynamic containers that adjust effortlessly to changes in size.
Example in Action:
Let's look into a quick example to see LinkedList in action:
import java.util.LinkedList;
class Example {
public static void main(String args[]) {
// Creating a LinkedList object
LinkedList myList = new LinkedList();
// Adding elements using add() and addLast() methods
myList.add("A");
myList.add("B");
myList.addLast("C");
// Print the current LinkedList
System.out.println(myList);
// Removing elements using remove() and removeFirst() methods
myList.remove("B");
myList.removeFirst();
// Print the LinkedList after deletion
System.out.println("Linked list after deletion: " + myList);
}
}
Output:
[A, B, C]
Linked list after deletion: [C]
In this example, we create a LinkedList of strings, add elements, and then remove some. The output shows how LinkedList adjusts itself as elements come and go.
Key Differences Between ArrayList and LinkedList
The table below lists the key differences between ArrayList and LinkedList:
| Key Differences |
ArrayList |
LinkedList |
| Implementation |
Uses a dynamic array to store elements. Supports storage of all types of objects |
Uses a doubly linked list to store elements. Supports storage of all types of objects |
| Manipulation Time |
Takes more time due to internal array traversal and shifting during removal |
Takes less time as there's no concept of shifting; reference links are changed during removal |
| Memory Utilization |
Inefficient memory utilization |
Good memory utilization |
| Dimensionality |
Can be one, two, or multi-dimensional |
Can be single, double, or circular LinkedList |
| Insertion Operation |
Slow |
Fast |
| Implemented Interfaces |
Implements the List interface |
Implements both List and Deque interfaces |
| Usage |
Works better for storing and accessing data |
Works better for manipulating stored data |
| Data Access and Storage |
Efficient as it stores elements according to indexes |
Slow in LinkedList |
| Deletion Operation |
Not very efficient |
Very efficient |
| Data Type Restriction |
Used to store only similar types of data |
Used to store any type of data |
| Memory Usage |
Uses less memory |
Uses more memory |
| Memory Allocation |
Known as static memory allocation |
Known as dynamic memory allocation |
These differences highlight the distinct characteristics and use cases for ArrayList and LinkedList in Java. Developers should choose the appropriate data structure based on the specific requirements of their application.
How Does ArrayList Work in Java?
An ArrayList in Java is akin to an array that can resize itself whenever necessary. When you create an ArrayList, Java allocates a memory where its elements are stored. As you add items, when the ArrayList is about 75% full, it gets a bigger memory block.
ArrayList name = new ArrayList();
For example, if you have an ArrayList of integers:
ArrayList numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
//
When it's nearly full, it gets more space automatically.
ArrayLists are part of the Java Collections framework in Java.util. Understanding this helps in making efficient and flexible Java programs.
How Does LinkedList Work in Java?
To a Java programmer, the LinkedList can be visualized as a linked chain of individual elements. Each element contains a block of information and references to the previous and next elements in the list.
To use a LinkedList, you declare it like this:
LinkedList name = new LinkedList<>();
For example, if you want a LinkedList of numbers:
LinkedList numbers = new LinkedList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
//...
It's like a dynamic chain where each piece (node) knows about its neighbors. This makes it handy for tasks involving lots of changes in the list. Understanding this makes using LinkedLists in Java simple and effective.
How to Insert Data in ArrayList?
In Java, the values can easily be added to an ArrayList.
Add at the end: Use add(object) to append the given object at the end of ArrayList.
ArrayList values = new ArrayList();values.add("apple");values.add("boy");values.add("cat");//
Now it has: apple, boy, cat
Insert at a specific position: Use the add method to insert an object at a given index, as shown within the following code snippet.
Now it has: apple, boy, cat
Now it becomes: apple, xyz, boy, cat
Remember, when inserting at a specific position, it takes more time for the computer, especially as the ArrayList gets bigger. But for most cases, it's fast enough!
How to Insert Values in LinkedList?
In Java, putting new values into a LinkedList is easy. You can add them at the end or a specific position without much hassle.
Add at the end: Use add(object) to add the given object at the end of the LinkedList.
LinkedList list = new LinkedList();list.add("100");list.add("200");list.add("300");//
Now it has: 100, 200, 300
Insert at a specific position: Utilize add (int index, Object e) to incorporate the given object inside a given index. Interestingly, unlike ArrayLists, there is no need to move elements around.
list.add(1, "xyz");
// Now it becomes: 100, xyz, 200, 300
As for the insertions, LinkedLists do them in a rather more efficient manner, and this applies whenever you need to insert things that are not at the beginning or end of the list.
How to Delete Values in ArrayList?
In Java, removing objects from an ArrayList is a common operation. Two methods, both named 'remove', make this process easy.
Using remove(object)
This function deletes the given object from the ArrayList. If the object appears multiple times, only the first occurrence is deleted.
// Assume we have an ArrayList named 'values'
ArrayList values = new ArrayList();
// Initial ArrayList: apple xyz boy cat dog elephant
// Deleting value "xyz"
values.remove("xyz");
//
Updated ArrayList: apple boy cat dog elephant
Using remove(int index)
This function deletes the data value stored at a given index. After deletion, all elements to the right of the deleted element are shifted to the left.
// Deleting value at index 1values.remove(1);// Updated ArrayList: apple boy cat dog elephant
Remember when deleting by index, the shifting of elements contributes to a time complexity of O(N), where N is the size of the ArrayList.
These 'remove' methods give you flexibility in managing your ArrayList by allowing you to delete specific values or values at specific positions easily.
How to Delete Values in LinkedList?
In Java, deleting objects from a LinkedList is a simple process. Two methods, both named 'remove', make this operation easy.
Using remove(object)
This function deletes the given object from the LinkedList. If the object appears multiple times, only the first occurrence is deleted.
// Assume we have a LinkedList named 'list'LinkedList list = new LinkedList();// Initial LinkedList: 100 200 300 400 500// Deleting value "200"list.remove("200");//
Updated LinkedList: 100 300 400 500
Using remove(int index)
This function erases the value of data that is stored at the explicitly specified index. Unlike ArrayLists, there is no need for shifting elements, making deletion a constant-time operation.
// Deleting value at index 1list.remove(1);//
Updated LinkedList: 100 300 400 500
These 'remove' methods provide a convenient way to manage your LinkedList by allowing you to easily delete specific values or values at specific positions without the need for shifting elements.
How To Choose Between ArrayList and LinkedList?
The choice between ArrayList and LinkedList depends on the various operations you want to implement in your data.
Search Operation
ArrayList: If you need to search for elements frequently, ArrayList is more efficient. It allows direct access to any position in constant time (O(1)) using mathematical computations.
LinkedList: For search operations, LinkedList is less efficient as it requires the following links, resulting in a time complexity of O(n) in the worst case. It's not ideal for scenarios where quick search access is a priority.
If you anticipate frequent search operations, especially when the position of elements is important, go for ArrayList. If searching is not a primary concern and you focus on other operations like frequent insertions or removals, LinkedList might be a better choice. The decision ultimately depends on the specific requirements of your application.
Get Ready for Your Java Developer Interview
Are you preparing for your Java developer interview? Join our free webinar! Receive guidance from industry professionals on how to ace technical interviews at leading firms.
At Interview Kickstart, we have assisted over 9000 engineers to secure offers from leading tech companies. Our instructors, experienced FAANG hiring managers, know what it takes to succeed in tough tech interviews.
Sign up for our free webinar now and gear up for a successful Java developer interview!
FAQs About ArrayList vs. LinkedList in Java
Q1. Is ArrayList synchronized?
No, it's not synchronized. For thread safety, consider synchronizing using Collections.synchronizedList(new ArrayList<>()).
Q2. Is insertion order maintained in ArrayList?
Yes, it maintains the order of elements based on their insertion sequence.
Q3. Is the ArrayList thread safe?
No, it's not thread-safe. Be cautious with concurrent modifications; consider synchronization or concurrent collections.
Q4. What is the difference between ArrayList and LinkedList stack?
ArrayList: dynamic array, better for random access.
LinkedList: doubly-linked list, efficient for insertions and removals.
Q5. Is ArrayList ordered in Java?
Yes, it maintains order based on the insertion sequence.
Q6. Does LinkedList maintain insertion order?
Yes, it does, similar to ArrayList.
Q7. What is the difference between ArrayList and array in Java?
ArrayList: dynamic, resizable array.
Array: fixed size, can't be changed once defined.
Q8. How does ArrayList size increase in Java?
Increases dynamically as elements are added. Auto reallocates and copies when nearing capacity.
