Core Java-Collection Interface Interview Questions

✅ In summary:

• Vector and Hashtable are thread-safe but slower (legacy classes).

• ArrayList and HashMap are faster and modern, but not synchronized by default — thread safety must be added manually when required.

✅ In short:

• Use HashMap when insertion order doesn’t matter and performance is key.

• Use LinkedHashMap when you need a predictable iteration order along with fast lookups.

🧠 How to Create a Generic Class in Java

Generics allow you to create classes, interfaces, and methods that can operate on different data types while providing type safety at compile time.

🧩 Defining a Generic Class

To define a generic class, specify a type parameter inside angle brackets (<>) right after the class name.

class Box<T> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

Explanation:

• T is a type parameter (a placeholder for any data type).

• By convention:

  • T → Type

  • E → Element (used in collections)

  • K, V → Key, Value (used in maps)

You can use this type placeholder in:

• Fields

• Method parameters

• Return types

⚙️ Using a Generic Class

When you create an instance, you specify the type that replaces the placeholder T:

public class Main {
    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>(123);
        Box<String> strBox = new Box<>("Hello Generics");

        System.out.println(intBox.getValue()); // Output: 123
        System.out.println(strBox.getValue()); // Output: Hello Generics
    }
}

Here:

• Box<Integer> → T is replaced with Integer

• Box<String> → T is replaced with String

This ensures type safety — you can’t accidentally assign a String to a Box<Integer>.

✅ Benefits of Generic Classes

🚀 In Short:

• Define a generic type placeholder using <T> next to the class name.

• Use T in fields, parameters, and return types.

• Replace T with a specific type when creating an object.

Generics make your code flexible, reusable, and safe — one class can handle any type while maintaining compile-time type checking.

⚙️ Fail-Fast vs Fail-Safe Iterators in Java

Iterators are used to traverse elements in collections.
Based on how they behave when a collection is modified during iteration, they are categorized as Fail-Fast or Fail-Safe.

🧩 Fail-Fast Iterators

• Used By: Traditional collection classes like ArrayList, HashSet, and HashMap.

• When you get an iterator from these collections and modify the collection (add/remove elements) while iterating, the iterator immediately throws a ConcurrentModificationException.

• This mechanism is designed to fail immediately to prevent inconsistent behavior.

🔍 Example:

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");

for (String s : list) {
    list.remove("A"); // ❌ Throws ConcurrentModificationException
}

🧩 Fail-Safe Iterators

• Used By: Concurrent collection classes such as CopyOnWriteArrayList, ConcurrentHashMap, and CopyOnWriteArraySet.

• These iterators do not throw exceptions when the collection is modified during iteration.

• They operate on a cloned copy (snapshot) of the collection, so modifications do not affect the iterator.

🔍 Example:

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("A");
list.add("B");

for (String s : list) {
    list.add("C"); // ✅ No exception, allowed
}

📊 Comparison: Fail-Fast vs Fail-Safe

✅ In short:

• Fail-Fast Iterators → Throw exception on concurrent modification (unsafe but faster).

• Fail-Safe Iterators → Allow concurrent modification safely (slightly slower but thread-safe).

If you need thread safety, use fail-safe iterators from concurrent collections.
If you need speed and are sure no concurrent modification will happen, fail-fast iterators are sufficient.