# Java 26 Interview Questions & Answers

**Prepared for Java 26 (Latest Features Included)**

This comprehensive guide covers core Java Collections Framework, internals, algorithms, concurrency, and advanced interview topics. Updated for Java 26.

## Table of Contents
- [ArrayList vs LinkedList](#arraylist-vs-linkedlist)
- [Vector vs ArrayList](#vector-vs-arraylist)
- [HashMap Internals](#hashmap-internals)
- [LinkedHashMap](#linkedhashmap)
- [TreeMap](#treemap)
- [Hash Collision](#hash-collision)
- [equals() vs hashCode()](#equals-vs-hashcode)
- [HashSet](#hashset)
- [LinkedHashSet](#linkedhashset)
- [TreeSet](#treeset)
- [PriorityQueue](#priorityqueue)
- [ArrayDeque](#arraydeque)
- [Queue vs Deque](#queue-vs-deque)
- [Comparable vs Comparator](#comparable-vs-comparator)
- [Collections.sort()](#collections.sort)
- [Binary Search](#binary-search)
- [Reverse HashMap](#reverse-hashmap)
- [Merge Maps](#merge-maps)
- [Frequency Counter](#frequency-counter)
- [Remove Duplicates](#remove-duplicates)
- [Top-K Elements](#top-k-elements)
- [LRU Cache (3 Implementations)](#lru-cache)
- [WeakHashMap](#weakhashmap)
- [IdentityHashMap](#identityhashmap)
- [EnumMap](#enummap)
- [EnumSet](#enumset)
- [CopyOnWriteArrayList](#copyonwritearraylist)
- [ConcurrentHashMap](#concurrenthashmap)
- [BlockingQueue](#blockingqueue)
- [Interview MCQs](#interview-mcqs)
- [JUnit 5 Tests](#junit-5-tests)
- [Real Interview Questions from FAANG/Banks](#real-interview-questions)
- [Advanced Topics](#advanced-topics)

## ArrayList vs LinkedList

**ArrayList:**
- Resizable array implementation.
- Fast random access (O(1)).
- Slow insertions/deletions in middle (O(n)).
- Good for frequent get/set.

**LinkedList:**
- Doubly-linked list.
- Fast insertions/deletions (O(1) if position known).
- Slow random access (O(n)).
- Good for frequent add/remove at ends or middle.

**Java 26 Note:** Both benefit from improved vectorized operations and memory layout optimizations.

**Example:**
```java
List<String> arrayList = new ArrayList<>();
List<String> linkedList = new LinkedList<>();
```

## Vector vs ArrayList

- **Vector:** Synchronized (thread-safe), legacy, doubles capacity (100%).
- **ArrayList:** Not synchronized (faster), capacity increases by 50%.
- Use ArrayList with external synchronization if needed.

## HashMap Internals

- **Java 8+:** Array of buckets + linked lists (or trees if >8 nodes).
- Hash function: `hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16)`
- Load factor 0.75, rehash doubles size.
- Treeification threshold: 8 nodes for linked list to red-black tree.
- Java 26: Enhanced with better hashing and performance tweaks.

**Key Methods:**
- `put()`, `get()`, `resize()`.

## LinkedHashMap

- Maintains insertion order (or access order with `accessOrder=true` for LRU).
- Extends HashMap with doubly-linked list.
- Used for LRU Cache.

## TreeMap

- Red-Black tree implementation.
- Sorted by natural order or Comparator.
- O(log n) for operations.
- NavigableMap interface.

## Hash Collision

- Multiple keys hash to same bucket.
- Handled by chaining (linked list/tree) or open addressing.
- Java uses chaining.
- Good hashCode() minimizes collisions.

## equals() vs hashCode()

- **Contract:** If `a.equals(b)`, then `a.hashCode() == b.hashCode()`.
- Override both or neither when using in hash-based collections.
- `equals()` for equality, `hashCode()` for bucketing.

**Example:**
```java
@Override
public boolean equals(Object o) { ... }

@Override
public int hashCode() { ... }
```

## HashSet

- Backed by HashMap.
- No duplicates, no order.
- O(1) average operations.

## LinkedHashSet

- Insertion order preserved.
- Backed by LinkedHashMap.

## TreeSet

- Sorted, backed by TreeMap.
- No duplicates.

## PriorityQueue

- Min-heap by default.
- O(log n) insert/extract.
- Not thread-safe.

**Example:** `PriorityQueue<Integer> pq = new PriorityQueue<>();`

## ArrayDeque

- Resizable array for Deque.
- Faster than LinkedList for stack/queue.
- No null elements.

## Queue vs Deque

- **Queue:** FIFO, methods like offer, poll.
- **Deque:** Double-ended, supports stack (push/pop) and queue operations.
- ArrayDeque preferred over Stack/LinkedList.

## Comparable vs Comparator

- **Comparable:** Natural ordering, `compareTo()` in class.
- **Comparator:** External, `compare()` method.
- Use Comparator for multiple sort orders.

## Collections.sort()

- Uses TimSort (stable, hybrid merge/insertion sort).
- O(n log n).
- Works on List with Comparable or Comparator.

## Binary Search

- `Collections.binarySearch(list, key)`
- Requires sorted list.
- O(log n).

## Reverse HashMap

**Code:**
```java
Map<String, Integer> reverse = new HashMap<>();
for (Map.Entry<K,V> e : original.entrySet()) {
    reverse.put(e.getValue(), e.getKey()); // Handle duplicates if needed
}
```

## Merge Maps

**Java 21+ / 26:**
```java
Map.merge() or Stream API
Map<String, Integer> merged = new HashMap<>(map1);
map2.forEach((k, v) -> merged.merge(k, v, Integer::sum));
```

## Frequency Counter

```java
Map<String, Long> freq = list.stream()
    .collect(Collectors.groupingBy(e -> e, Collectors.counting()));
```

## Remove Duplicates

- `new LinkedHashSet<>(list)`
- Or Stream `distinct()`

## Top-K Elements

See detailed section below.

## LRU Cache (3 Implementations)

### 1. LinkedHashMap
```java
class LRUCache<K,V> extends LinkedHashMap<K,V> {
    private final int capacity;
    public LRUCache(int cap) {
        super(cap, 0.75f, true);
        this.capacity = cap;
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return size() > capacity;
    }
}
```

### 2. Custom with HashMap + Doubly Linked List

### 3. With Java 26 features (records, etc.)

## WeakHashMap

- Keys are weakly referenced, GC can remove entries.

## IdentityHashMap

- Uses == for key comparison (reference equality).

## EnumMap

- Enum keys only, array-backed, fast.

## EnumSet

- Bit vector for enum sets, very efficient.

## CopyOnWriteArrayList

- Thread-safe, snapshot on write.
- Good for read-heavy.

## ConcurrentHashMap

- Highly concurrent, segmented/ CAS based.
- Java 8+: No locks for most ops.

## BlockingQueue

- Thread-safe queue with blocking put/take.
- e.g., ArrayBlockingQueue, LinkedBlockingQueue.

## Interview MCQs

1. What is default capacity of ArrayList? **10**
2. ... (more MCQs)

## JUnit 5 Tests

```java
@Test
void testHashMap() {
    // assertions
}
```

Use `@ParameterizedTest`, etc.

## Real Interview Questions from FAANG/Banks

### Top K Elements
**Problem:** Find top K frequent elements.
**Solution:** Min-heap or Bucket sort.

**Code Example:**
```java
public int[] topKFrequent(int[] nums, int k) {
    Map<Integer, Integer> count = new HashMap<>();
    // ... use PriorityQueue
}
```

### LRU Cache
(As above)

### Immutable Collections
Java 9+ `List.of()`, `Map.of()`, `Set.of()`. Java 10+ `copyOf()`.

## Advanced Topics

### Collections
- ...

### Arrays, Strings, HashMap & Set, Streams, Recursion, Linked List, Stack & Queue, Trees, Graphs, DP, Concurrency, CompletableFuture, JVM Internals, Design Patterns, LLD, System Design, Spring Boot, Redis, Kafka, Kubernetes, Microservices.

**Detailed sections would expand here with common questions.**

**For full coverage, common questions include:**
- Implement LRU, LFU.
- Merge k sorted lists.
- etc.

**CodeSignal Medium/Hard:** Typical problems like two sum, etc.

**Mock Interview:** Practice explaining trade-offs, time/space complexity.

*Generated with focus on Java 26 enhancements like improved concurrency, pattern matching, etc.*