何时及为何选择从零实现LinkedList而非使用java.util.LinkedList？

Great question! As someone who's both relied on java.util.LinkedList for everyday tasks and rolled my own custom implementations a handful of times, let me break down the scenarios and reasoning behind choosing to build your own instead of using the standard library.

1. Learning & Educational Purposes #

This is by far the most common scenario. If you want to truly grok how linked lists work under the hood—from managing node pointers, handling edge cases like empty lists or head/tail modifications, to understanding the tradeoffs between linked and array-based lists—writing your own implementation is the best way. Most CS courses force students to code linked lists for exactly this reason: it turns abstract concepts into tangible, working code, rather than just knowing how to call add() or remove() on a pre-built class.

2. Extreme Performance or Memory Optimization #

java.util.LinkedList is a general-purpose implementation, which means it comes with overhead you might not need:

• It's a doubly linked list, so every node has both prev and next pointers—wasting memory if you only need a singly linked list.
• It implements a slew of interfaces (List, Deque, Cloneable, Serializable) and inherits from AbstractSequentialList, adding layers of abstraction that can slow down operations.
  If your use case is narrow (e.g., only FIFO operations, or single-pass traversal), a custom singly linked list can cut memory usage (by ditching the prev pointer) and speed up operations by skipping unnecessary checks or interface compliance logic. I once built a tiny singly linked list for an embedded device's log system—this cut memory overhead by ~25% compared to the standard library version, which was critical for the device's limited RAM.

3. Custom Features or Constraints #

The standard LinkedList is designed to be flexible for all general cases, but it can't accommodate niche business or algorithmic needs:

• Immutable linked lists: The standard library's LinkedList is mutable, and wrapping it with Collections.unmodifiableList() is a workaround that still carries the mutable underlying structure's overhead. A custom immutable implementation (where every modification returns a new node) is cleaner, safer for concurrent code, and fits functional programming patterns.
• Built-in sorting/deduplication: If you need elements to stay sorted automatically as they're added, or want to block duplicates entirely, doing this manually with the standard LinkedList is inefficient. A custom implementation can handle sorting/deduplication during insertion, avoiding post-processing steps.
• Custom hooks: Want to trigger a callback every time a node is added or removed? The standard library has no extension points for this. Building your own lets you inject custom logic directly into core operations.

4. Reducing Dependency Bloat #

In lightweight environments—like embedded systems, tiny utility libraries, or code that needs to be as self-contained as possible—you might not want to pull in the entire Java Collections Framework. A custom linked list with only the features you need (e.g., just addLast() and removeFirst()) keeps your codebase small and avoids unnecessary dependencies.

5. Specialized Linked List Variants #

java.util.LinkedList is a basic doubly linked list, but there are many variants the standard library doesn't provide:

• Circular linked lists (where the tail points back to the head)
• Linked lists with sentinel nodes (to simplify edge case handling)
• Skip lists (a sorted linked list variant for fast lookups)
  If your algorithm or problem requires one of these, you have no choice but to build it yourself.

To boil it down, the main justifications for rolling your own are:

• Deep understanding: Learning the internals of data structures by building them from scratch.
• Targeted optimization: Cutting overhead for specific use cases where the general-purpose standard library is overkill.
• Customization: Adding behavior or constraints that the standard library doesn't support.
• Lightweight code: Avoiding dependency bloat in resource-limited or minimalistic environments.
• Specialized structures: Implementing linked list variants not available in the JDK.

内容的提问来源于stack exchange，提问作者Momo Shaheen