为何Java 8中java.util.List新增sort方法？已有Collections.sort可用

Great question! Let’s dive into the key reasons behind this API change, which made sorting lists feel more intuitive and aligned with Java 8’s overall design shifts.

• OOP Principles: Let the List Manage Its Own Behavior
  Before Java 8, sorting a list meant calling the static Collections.sort() method and passing your list as an argument. This felt disconnected—like asking an external utility to do something the list should handle itself. With List.sort(), the operation becomes a natural part of the list’s own methods, following the "tell, don’t ask" principle. Compare the two:

  // Pre-Java 8
  Collections.sort(myShoppingList);
  
  // Java 8+
  myShoppingList.sort(null); // Uses natural ordering
  

  It’s a small shift, but it makes the code read more like plain English: "Hey list, sort yourself."

• Seamless Integration with Lambdas and Streams
  Java 8’s biggest additions were lambda expressions and the Stream API. The List.sort() method was built to play nicely with both. Since sort() accepts a Comparator parameter, you can pass a lambda directly, or use the new static methods in Comparator (like comparing() or reverseOrder()) for super concise code:

  myShoppingList.sort(Comparator.comparing(Item::getPrice).reversed());
  

  This fits perfectly with the fluent, chainable style of Java 8’s APIs, avoiding the jarring jump to a static utility method when working with streams or lambda-heavy code.

• Default Methods Made Interface Evolution Possible
  Before Java 8, interfaces couldn’t have concrete method implementations—adding a new method to List would have broken every existing implementation (think ArrayList, LinkedList, etc.). But Java 8 introduced default methods, which let interfaces include method bodies. The List.sort() method is a default method that simply delegates to Collections.sort(this, comparator) under the hood. This meant the JDK team could extend the List interface without breaking backward compatibility.

• Consistent API Experience
  If you look at the List interface, most core operations (like add(), remove(), forEach()) are instance methods. Adding sort() as an instance method makes the API feel more consistent. Developers no longer have to remember which collection operations live in utility classes vs. on the collection itself—it’s all right there on the list instance.

• Improved Readability and Conciseness
  Let’s be honest: instance method calls are easier to scan. When you’re reading through code, seeing myList.sort(...) immediately tells you what’s happening to that specific list. Static method calls require a split second to connect the utility class to the list being operated on. For complex code with multiple operations, this small readability boost adds up.

内容的提问来源于stack exchange，提问作者shuchita khurana