Java | Working with ArrayLists, LinkedLists, and Vectors

In Java programming, arrays are a powerful tool for storing and manipulating collections of data. However, arrays have a fixed size, which can be limiting in some cases. To work with collections of data that can grow or shrink dynamically, Java provides three built-in classes: ArrayList, LinkedList, and Vector. In this blog post, we will explore these classes in detail, including their similarities and differences, and provide examples of how to use them in Java programs.

ArrayList:

ArrayList is a class in Java that provides an implementation of a dynamic array. It allows you to add, remove, and access elements in the array, and automatically resizes the array as needed. Here’s an example of how to create an ArrayList of strings and add elements to it:

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList<String> myArrayList = new ArrayList<String>();
        myArrayList.add("apple");
        myArrayList.add("banana");
        myArrayList.add("cherry");
        System.out.println(myArrayList);
    }
}

In this example, we import the ArrayList class, create an ArrayList of strings called myArrayList, and add three elements to it. Finally, we print the contents of the ArrayList using the System.out.println() method.

LinkedList:

LinkedList is another class in Java that provides an implementation of a dynamic data structure, but instead of using an array, it uses a linked list. This makes it more efficient than ArrayList for inserting and deleting elements in the middle of the list, but less efficient for accessing elements by index. Here’s an example of how to create a LinkedList of integers and add elements to it:

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<Integer> myLinkedList = new LinkedList<Integer>();
        myLinkedList.add(1);
        myLinkedList.add(2);
        myLinkedList.add(3);
        System.out.println(myLinkedList);
    }
}

In this example, we import the LinkedList class, create a LinkedList of integers called myLinkedList, and add three elements to it. Finally, we print the contents of the LinkedList using the System.out.println() method.

Vector:

Vector is a class in Java that provides a dynamic array similar to ArrayList, but with one important difference: it is synchronized. This means that multiple threads can safely access and modify the contents of a Vector object without causing data corruption. Here’s an example of how to create a Vector of doubles and add elements to it:

import java.util.Vector;

public class VectorExample {
    public static void main(String[] args) {
        Vector<Double> myVector = new Vector<Double>();
        myVector.add(1.1);
        myVector.add(2.2);
        myVector.add(3.3);
        System.out.println(myVector);
    }
}

In this example, we import the Vector class, create a Vector of doubles called myVector, and add three elements to it. Finally, we print the contents of the Vector using the System.out.println() method.

Conclusion:

In this blog post, we explored the ArrayList, LinkedList, and Vector classes in Java, including their similarities and differences, and provided examples of how to use them in Java programs. Each of these classes provides a dynamic data structure that can be used to store and manipulate collections of data, with their own unique features and benefits. By understanding the differences between these classes, you can choose the one that best fits your needs and write more efficient

Leave a Reply Cancel reply