5.JDK

Java's Cloneable marker interface, shallow copying, constructor bypass, and why explicit copy APIs are usually clearer.

Integer boxing/unboxing, value comparison, caching, parsing, overflow, and null-unboxing hazards.

ArrayList's resizable-array model, complexity, capacity growth, iteration, and concurrency characteristics.

Legacy Hashtable synchronization, null restrictions, and modern replacement choices.

Core Object methods: equals/hashCode, toString, class identity, monitor methods, and cloning/finalization caveats.

Heap-based priority queues, ordering semantics, complexity, and concurrency limitations.

Java native serialization, serialVersionUID, compatibility, security risks, and modern alternatives for service/data formats.

Hash-based Set semantics, equality/hashCode requirements, null handling, and concurrency characteristics.

Java String immutability, pooling, equality, concatenation, encoding boundaries, and implementation-sensitive storage.

Java LinkedList as a doubly linked List/Deque, with operation costs and cache-locality trade-offs.

Insertion/access-order HashMap with a linked iteration order and the basis of simple LRU-style maps.

Designing Java immutable objects and the concurrency benefits of stable state.

A HashSet variant with deterministic insertion-order iteration.

Legacy synchronized mutable text builder and its relationship to StringBuilder.

Safe Java List/array conversion and the mutability semantics of Arrays.asList and modern collection factories.

Choosing HashMap, LinkedHashMap, TreeMap, ConcurrentHashMap, and synchronized/legacy maps.

Synchronized Set wrappers and the need for external synchronization during compound operations and iteration.

Efficient mutable text construction, capacity, non-thread-safety, and compiler concatenation optimizations.

Choosing among ArrayList, LinkedList, CopyOnWriteArrayList, and synchronized wrappers by access pattern.

Synchronized Map wrappers, compound-operation atomicity, iteration locking, and concurrent alternatives.

Sorted/navigable set semantics, comparator ordering, and logarithmic tree operations.

String identity, content equality, ordering, null safety, and case-insensitive comparison cautions.

The synchronized List wrapper, compound operations, iteration requirements, and alternatives.

Sorted and navigable maps, key ordering, logarithmic operations, and comparator consistency.

Legacy synchronized Vector behavior and why ArrayList or specialized concurrent collections are usually preferred.

What ConcurrentModificationException means, structural modification tracking, and why fail-fast behavior is not a thread-safety guarantee.

Historical JDK 7 HashMap bucket-chain implementation and resize behavior, clearly separated from modern JDK internals.

Historical JDK 8 HashMap array/bin/tree design, resize concepts, load factor, and stable API-level lessons.