编辑“︁Java集合排序”︁

{{Note|本教程适用于Java 8及以上版本。部分特性在早期版本中可能不可用。}}

= Java集合排序 =

'''Java集合排序'''是指对Java集合框架（Java Collections Framework）中的元素按照特定规则进行排列的操作。排序是数据处理中的基础操作，Java提供了多种方式来实现集合排序。

== 概述 ==

Java集合框架中的List接口实现类（如ArrayList、LinkedList等）存储的元素默认是按照插入顺序保存的。但在实际开发中，我们经常需要按照某种规则（如数字大小、字母顺序、自定义规则等）对元素进行排序。

Java提供了两种主要的排序方式：
# 使用[[java.util.Collections#sort(java.util.List)|Collections.sort()]]方法
# 使用[[java.util.List#sort(java.util.Comparator)|List.sort()]]方法（Java 8+）

== 自然排序 ==

自然排序是指使用元素的自然顺序（即实现Comparable接口定义的顺序）进行排序。

=== 示例：对整数列表排序 ===

<syntaxhighlight lang="java">
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class NaturalSortingExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 2, 9, 1, 5, 6);
        
        // 使用Collections.sort()进行自然排序
        Collections.sort(numbers);
        
        System.out.println("排序后的列表: " + numbers);
    }
}
</syntaxhighlight>

'''输出:'''
<pre>
排序后的列表: [1, 2, 5, 5, 6, 9]
</pre>

== 自定义排序 ==

当需要按照非自然顺序排序时，可以使用Comparator接口定义自定义排序规则。

=== 示例：按字符串长度排序 ===

<syntaxhighlight lang="java">
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class CustomSortingExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "pear", "orange");
        
        // 使用匿名Comparator按字符串长度排序
        words.sort(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return Integer.compare(s1.length(), s2.length());
            }
        });
        
        System.out.println("按长度排序: " + words);
    }
}
</syntaxhighlight>

'''输出:'''
<pre>
按长度排序: [pear, apple, banana, orange]
</pre>

=== Java 8 Lambda表达式简化 ===

Java 8可以使用Lambda表达式简化Comparator的编写：

<syntaxhighlight lang="java">
words.sort((s1, s2) -> Integer.compare(s1.length(), s2.length()));
</syntaxhighlight>

或者使用方法引用：

<syntaxhighlight lang="java">
words.sort(Comparator.comparingInt(String::length));
</syntaxhighlight>

== 多条件排序 ==

实际应用中，经常需要按照多个条件进行排序。Comparator.thenComparing()方法可以实现这一点。

=== 示例：先按年龄再按姓名排序 ===

<syntaxhighlight lang="java">
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

class Person {
    String name;
    int age;
    
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}

public class MultiFieldSorting {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 25),
            new Person("Bob", 30),
            new Person("Charlie", 25),
            new Person("David", 30)
        );
        
        // 先按年龄升序，再按姓名升序
        people.sort(Comparator.comparingInt(Person::getAge)
                             .thenComparing(Person::getName));
        
        System.out.println("多条件排序结果: " + people);
    }
}
</syntaxhighlight>

'''输出:'''
<pre>
多条件排序结果: [Alice(25), Charlie(25), Bob(30), David(30)]
</pre>

== 逆序排序 ==

Java提供了多种方式实现逆序排序：

=== 使用Collections.reverseOrder() ===

<syntaxhighlight lang="java">
Collections.sort(numbers, Collections.reverseOrder());
</syntaxhighlight>

=== 使用Comparator.reversed() ===

<syntaxhighlight lang="java">
words.sort(Comparator.comparingInt(String::length).reversed());
</syntaxhighlight>

== 性能考虑 ==

Java的排序算法使用优化后的归并排序（针对对象）和双轴快速排序（针对基本类型），时间复杂度为O(n log n)。

对于大型集合，排序可能消耗较多内存和时间。可以考虑：
* 使用并行排序（Java 8+的parallelSort）
* 对已部分排序的数据使用更适合的算法

== 实际应用案例 ==

=== 电商商品排序 ===

电商网站通常需要多种商品排序方式：

<syntaxhighlight lang="java">
class Product {
    String name;
    double price;
    int sales;
    Date createTime;
    // 省略getter/setter
}

public class ECommerceSorting {
    public static void main(String[] args) {
        List<Product> products = getProducts(); // 获取商品列表
        
        // 按价格从低到高
        products.sort(Comparator.comparingDouble(Product::getPrice));
        
        // 按销量从高到低
        products.sort(Comparator.comparingInt(Product::getSales).reversed());
        
        // 综合排序：销量优先，价格其次
        products.sort(Comparator.comparingInt(Product::getSales).reversed()
                              .thenComparingDouble(Product::getPrice));
    }
}
</syntaxhighlight>

== 常见问题 ==

=== 不可变集合排序 ===

尝试对Collections.unmodifiableList()返回的不可变集合排序会抛出UnsupportedOperationException。应先创建可修改的副本。

=== 自定义对象的自然排序 ===

要使自定义对象支持自然排序，需要实现Comparable接口：

<syntaxhighlight lang="java">
class Student implements Comparable<Student> {
    String name;
    int grade;
    
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.grade, other.grade);
    }
}
</syntaxhighlight>

== 高级主题 ==

=== 并行排序 ===

Java 8引入了并行数组排序：

<syntaxhighlight lang="java">
Arrays.parallelSort(array);  // 对基本类型数组有效
</syntaxhighlight>

对于大型集合，并行排序可以利用多核处理器提高性能。

=== 稳定排序 ===

Java的排序算法是稳定的，即相等元素的相对顺序在排序前后保持不变。这在多条件排序中很重要。

== 总结 ==

Java集合排序是日常开发中的常见操作，掌握各种排序技巧能显著提高编码效率。关键点包括：
* 理解Comparable和Comparator的区别
* 掌握Lambda表达式简化Comparator编写
* 了解多条件排序的实现方式
* 注意排序的性能影响

通过合理使用Java提供的排序工具，可以优雅地解决各种排序需求。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java集合框架]]