• Java Collection framework added in J2SE 1.2 release.
• Collections are set of classes and interfaces.
• By using Collections we can store and manipulate objects easily.
• Collections can hold heterogeneous data elements.
• Collections are no fixed in size and dynamically increase in size.
• Collection of objects. No primitives.
• All collection classes having underlying data structure.
• Collections are good with respect to memory. Bad with respect to performance.

Collection interface Hierarchy:

•  java.util package contains all collections classes and interfaces.
• Lets see collection interface hierarchy.
• under Collection. Set , List , Queue are the sub interfaces.

Collections Abstract classes and classes:

• Let us see  all the abstract classes implementing all the above interfaces and classes which extending these abstract classes.
• To Collect Objects in array format we choose Collection hierarchy classes.
• Main abstract class is AbstractCollection.
• AbstractSet
• AbstractList
• AbstractQueue
• AbstractSequentialList
• All the classes in Collection hierarchy are
• TreeSet
• HashSet
• LinkedHashSet
• LinkedList
• ArrayList
• Vector
• Stack
• PriorityQueue 
• To collect unique elements we must choose Set implemented classes
• To collect unique and duplicate elements in indexed order we choose List implemented classes.
• To retrieve elements in FIFO manner we choose Queue implemented classes.

Map Hierarchy:

• In this hierarchy Hashtable and properties classes are avilable since java 1.0.
• LinkedHashMap class is available since java 1.4
• NavigableMap is available since java 6 and all other classes available since java 1.2.
• SortedMap and NavigableMap are two main interfaces.
• TreeMap
• HashMap
• LinkedHashMap
• Hashtable
• Properties are the classes. 
• To collect objects in key, value pair format we choose Map hierarchy classes.

import java.util.*;

public class MapToListExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        // Convert values to List
        List<String> list = new ArrayList<>(map.values());

        System.out.println(list);  // Output: [Apple, Banana, Cherry]
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class MapToListExample {
    public static void main(String[] args) {
        Map<Integer, String> map = Map.of(1, "Apple", 2, "Banana", 3, "Cherry");

        // Convert values to List using Stream
        List<String> list = map.values().stream().collect(Collectors.toList());

        System.out.println(list);  // Output: [Apple, Banana, Cherry]
    }
}

import java.util.*;

public class MapToListExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");

        List<String> list = new ArrayList<>();
        map.values().forEach(list::add);

        System.out.println(list);  // Output: [Apple, Banana, Cherry]
    }
}

• Iterator is implemented on all Java collection classes.
• Iterator uses iterator() method.
• Iterator can traverse in forward direction only.
• Iterator having methods like hasNext(), next(), remove().

Program:

Output:

• ListIterator is implemented only for List type classes
• ListIterator uses listIterator() method.
• ListIterator can traverse in forward and backward directions.
• ListIterator having methods like 
• hasNext()
• next()
• previous()
• hasPrevious()
• remove()
• nextIndex()
• previousIndex().

Program:

Output:

1. HashMap
2. LinkedHashMap
3. HashaTable
4. TreeMap

HashMap:

• HashMap is not synchronized.
• Hashmap allows one key null and multiple null values.
• HashMap default capacity is :

static final int DEFAULT_INITIAL_CAPACITY =16 static final float DEFAULT_LOAD_FACTOR = 0.75f;

Program for HashMap:

Output:

indhira
swathi
indhu
sindhu
sindhu

HashTable:

• HashTable is synchronized.
• HashTable doesn't allow any null key or any null values.
• HasTable Default capacity:

static final int DEFAULT_INITIAL_CAPACITY = 11;static final float DEFAULT_LOAD_FACTOR = 0.75f;
Program for HashTable:

package com.instanceofjava;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class Hashtable3{

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Hashtable hashTable=new Hashtable();
hashTable.put(1, "indhu");
hashTable.put("d", "sindhu");
hashTable.put("3", "swathi");
hashTable.put("d", "sindhu");
if(!hashTable.isEmpty()){
Iterator it=hashTable.entrySet().iterator();
while(it.hasNext()){
Map.Entry obj=(Entry) it.next();
System.out.println(obj.getValue());
}


}
}

}
TreeMap:

• TreeMap is sorted order.
• TreeMap doesn't allow null key or null values.

Program for TreeMap:

package com.instanceofjava;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

public class Employee{

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeMap treeMap=new TreeMap();
treeMap.put("g", "indhu");
treeMap.put("d", "sindhu");
treeMap.put("3", "swathi");
treeMap.put("d", "sindhu");
if(!treeMap.isEmpty()){
Iterator it=treeMap.entrySet().iterator();
while(it.hasNext()){
Map.Entry obj=(Entry) it.next();
System.out.println(obj.getValue());
}


}
}

}

• The group of strings what we are passing as an argument to the main method from the console or command line are known as command line arguments.
• Every command line argument would be accepted by the JVM in the form of a String object.
• JVM will always executes main method by passing object of an array of strings.
• JVM would never execute main method by passing null
• JVM always executes main as a thread. 

• Vector is  synchronized. Synchronization and thread safe means at a time only one thread can access the code .In Vector class all the methods are synchronized .That's why the Vector object is already synchronized when it is created .
• ArrayList is not synchronized.

How To Make ArrayList synchronized:

• We have direct method in collections class to make Arrraylist as Synchronized.
• List li=new ArrayList();
• Collections.synchrinizedlist(li);

Automatic Increase in Capacity:

• A Vector defaults to doubling size of its array.
• ArrayList increases it's size by 50%.

• Vector is slower than ArrayaList.
• ArrayList is faster than Vector.

Introduction to the Java List Interface

The List interface in Java forms part of the core of the Java Collections Framework. It offers access to an ordered list of objects. In contrast with sets, lists allow duplicates as well as maintain insertion order. This makes lists perfect for sequences. When sequence matters, the List interface in Java is useful for modeling things like user input, products returned from a database query, or steps in a workflow.

In this guide, you'll find the List interface and its implementing classes: ArrayList, LinkedList, Vector, and Stack. We will examine their performance characteristics, use cases, and best practices to help you select the right one for any given project.

Key Characteristics of the List Interface

• Accepted Elements: Elements maintain their order of insertion.
• Index-based access: Retrieve, add, or remove elements by position.
• Duplicates allowed: Lists can contain the same item more than once.
• Null-Safe: Most implementations of List allow null values.

Classes that Implement the List Interface

1. ArrayList

• What It Is: A resizable array implementation.
• When to Use: Ideal for read-heavy, random access operations.
• Performance:
  • Access: O(1) (fast for get() and set()).
  • Insert/Delete: O(n) (because shifting items is required).

Example:

List<String> fruits = new ArrayList<>();
fruits.add("Apple");  
fruits.add("Banana");  
System.out.println(fruits.get(0)); // Output: Apple  

2. LinkedList

• What It Is: A doubly-linked list implementation.
• When to Use: Ideal for frequent insertions and deletions.
• Performance:
  • Access: O(n) (poor for random access).
  • Insert/Delete: O(1) (when modifying head or tail).

Example:

List<Integer> numbers = new LinkedList<>();
numbers.add(10);  
numbers.addFirst(5); // Add at head  

3. Vector

• What It Is: An array-based list that is thread-safe.
• When to Use: In multi-threading environments (although ArrayList with explicit synchronization is preferred).
• Disadvantage: Being synchronized makes it slower than ArrayList.

Example:

List<String> colors = new Vector<>();
colors.add("Red");  
colors.add("Blue");  

4. Stack

• What It Is: A Vector subclass that implements LIFO (Last-In-First-Out).
• Methods:push(), pop(), peek().
• When to Use: For undo/redo operations, parsing expressions, and backtracking algorithms.

Example:

Stack<String> stack = new Stack<>();
stack.push("Task1");  
stack.push("Task2");  
System.out.println(stack.pop()); // Output: Task2  

ArrayList Vs. LinkedList Vs. Vector Vs. Stack

Class	Underlying Data	Thread-Safe?	Use Cases
ArrayList	Dynamic array	No	Read-heavy operations
LinkedList	Doubly linked list	No	Frequent insertions/deletions
Vector	Array	Yes	Legacy applications
Stack	Array (Vector)	Yes	LIFO-based operations

Best Practices When Using Java Lists

1. Choose the Right Implementation:
   • Default to ArrayList for most use cases.
   • Use LinkedList for queue-like behavior (addFirst(),removeLast()).
2. Avoid Synchronized Classes: Use Collections.synchronizedList() with ArrayList instead of Vector.
3. Preallocate Capacity: Initialize larger ArrayLists with a capacity to reduce resizing overhead.
4. Leverage Java 8+ Features: Use streams and lambda functions for filtering, mapping, and sorting.

---

Frequently Asked Questions on Java Lists

Question 1: When should I use ArrayList as opposed to LinkedList?

• ArrayList: Best for random access and read-heavy operations.
• LinkedList: Best for frequent insertions/deletions.

Question 2: Is Vector still relevant in modern-day Java?

• Vector is largely outdated. Use CopyOnWriteArrayList or java.util.concurrent classes for thread safety.

Question 3: How do I convert a List to an array?

• Use String[] array = list.toArray(new String[0]);

4: How do I sort a List?

• Use Collections.sort(list) or list.sort(Comparator).

By mastering the Java List interface and its implementations, you can write efficient, scalable code. Whether you are building high-performance applications with ArrayLists, managing complex workflows with LinkedLists, or using Vectors for legacy applications, understanding their strengths and weaknesses is key.

Found this guide helpful? Share with a friend!

Stay tuned for more tutorials on Java Collections, Spring Boot, and System Design.

Keywords: Java List interface, ArrayList vs LinkedList, Vector and Stack in Java, Java Collections tutorial, List implementations in Java.