如何用Java案例实现数据排序？

本文目录导读：

1. 数组排序（基础案例）
2. 自定义对象排序
3. 常用排序算法实现
4. 实际应用案例：学生成绩管理系统
5. 性能对比测试

我来为你提供几个Java实现数据排序的案例,包括常用排序算法和实际应用场景。

数组排序（基础案例）

import java.util.Arrays;
public class ArraySortDemo {
    public static void main(String[] args) {
        // 1. 基本类型数组排序
        int[] numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6};
        System.out.println("排序前: " + Arrays.toString(numbers));
        Arrays.sort(numbers);
        System.out.println("排序后: " + Arrays.toString(numbers));
        // 2. 字符串数组排序
        String[] names = {"张三", "李四", "王五", "赵六", "孙七"};
        Arrays.sort(names);
        System.out.println("姓名排序: " + Arrays.toString(names));
    }
}

自定义对象排序

import java.util.*;
// 定义学生类实现Comparable接口
class Student implements Comparable<Student> {
    private String name;
    private int age;
    private double score;
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    // 按照年龄排序
    @Override
    public int compareTo(Student other) {
        return this.age - other.age;
    }
    @Override
    public String toString() {
        return String.format("Student{name='%s', age=%d, score=%.1f}", 
                           name, age, score);
    }
    // getter方法
    public String getName() { return name; }
    public int getAge() { return age; }
    public double getScore() { return score; }
}
public class ObjectSortDemo {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三", 20, 85.5));
        students.add(new Student("李四", 18, 92.0));
        students.add(new Student("王五", 22, 78.5));
        // 1. 使用Comparable接口排序（按年龄）
        Collections.sort(students);
        System.out.println("按年龄排序:");
        students.forEach(System.out::println);
        // 2. 使用Comparator自定义排序（按成绩）
        Comparator<Student> byScore = 
            (s1, s2) -> Double.compare(s2.getScore(), s1.getScore());
        students.sort(byScore);
        System.out.println("\n按成绩降序排序:");
        students.forEach(System.out::println);
        // 3. 多条件排序（先按年龄，再按成绩）
        Comparator<Student> multiComparator = 
            Comparator.comparing(Student::getAge)
                     .thenComparing(Student::getScore);
        students.sort(multiComparator);
        System.out.println("\n多条件排序:");
        students.forEach(System.out::println);
    }
}

常用排序算法实现

import java.util.Arrays;
public class SortingAlgorithmsDemo {
    // 1. 冒泡排序
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false;
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) break; // 优化：如果没有交换，说明已经有序
        }
    }
    // 2. 选择排序
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIdx]) {
                    minIdx = j;
                }
            }
            // 交换最小元素到当前位置
            int temp = arr[minIdx];
            arr[minIdx] = arr[i];
            arr[i] = temp;
        }
    }
    // 3. 插入排序
    public static void insertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }
    // 4. 快速排序
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }
    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                // 交换arr[i]和arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // 将pivot放到正确位置
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }
    // 5. 归并排序
    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }
    private static void merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];
        int i = left, j = mid + 1, k = 0;
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) temp[k++] = arr[i++];
        while (j <= right) temp[k++] = arr[j++];
        System.arraycopy(temp, 0, arr, left, temp.length);
    }
    public static void main(String[] args) {
        // 测试各种排序算法
        int[] arr1 = {64, 34, 25, 12, 22, 11, 90};
        int[] arr2 = arr1.clone();
        int[] arr3 = arr1.clone();
        int[] arr4 = arr1.clone();
        int[] arr5 = arr1.clone();
        System.out.println("原始数组: " + Arrays.toString(arr1));
        bubbleSort(arr1);
        System.out.println("冒泡排序: " + Arrays.toString(arr1));
        selectionSort(arr2);
        System.out.println("选择排序: " + Arrays.toString(arr2));
        insertionSort(arr3);
        System.out.println("插入排序: " + Arrays.toString(arr3));
        quickSort(arr4, 0, arr4.length - 1);
        System.out.println("快速排序: " + Arrays.toString(arr4));
        mergeSort(arr5, 0, arr5.length - 1);
        System.out.println("归并排序: " + Arrays.toString(arr5));
    }
}

实际应用案例：学生成绩管理系统

import java.util.*;
import java.util.stream.Collectors;
class StudentGrade implements Comparable<StudentGrade> {
    private int id;
    private String name;
    private int chinese;
    private int math;
    private int english;
    private int total;
    public StudentGrade(int id, String name, int chinese, int math, int english) {
        this.id = id;
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
        this.total = chinese + math + english;
    }
    @Override
    public int compareTo(StudentGrade other) {
        return Integer.compare(other.total, this.total); // 按总分降序
    }
    @Override
    public String toString() {
        return String.format("%-4d %-8s 语文:%-4d 数学:%-4d 英语:%-4d 总分:%-4d", 
                           id, name, chinese, math, english, total);
    }
    // getter方法
    public int getId() { return id; }
    public String getName() { return name; }
    public int getTotal() { return total; }
    public int getChinese() { return chinese; }
    public int getMath() { return math; }
    public int getEnglish() { return english; }
}
public class GradeSortSystem {
    private List<StudentGrade> students;
    public GradeSortSystem() {
        this.students = new ArrayList<>();
        initData();
    }
    private void initData() {
        students.add(new StudentGrade(1001, "张三", 85, 92, 78));
        students.add(new StudentGrade(1002, "李四", 92, 88, 95));
        students.add(new StudentGrade(1003, "王五", 78, 85, 90));
        students.add(new StudentGrade(1004, "赵六", 95, 90, 88));
        students.add(new StudentGrade(1005, "孙七", 88, 76, 82));
    }
    // 按总分排序
    public void sortByTotalScore() {
        Collections.sort(students);
        displayResults("按总分排序");
    }
    // 按单科成绩排序
    public void sortBySubject(String subject) {
        Comparator<StudentGrade> comparator;
        switch (subject.toLowerCase()) {
            case "chinese":
                comparator = Comparator.comparingInt(StudentGrade::getChinese).reversed();
                break;
            case "math":
                comparator = Comparator.comparingInt(StudentGrade::getMath).reversed();
                break;
            case "english":
                comparator = Comparator.comparingInt(StudentGrade::getEnglish).reversed();
                break;
            default:
                throw new IllegalArgumentException("无效科目: " + subject);
        }
        students.sort(comparator);
        displayResults("按" + subject + "成绩排序");
    }
    // 使用Stream API进行排序
    public void sortWithStream(String field) {
        Comparator<StudentGrade> comparator;
        switch (field.toLowerCase()) {
            case "id":
                comparator = Comparator.comparingInt(StudentGrade::getId);
                break;
            case "name":
                comparator = Comparator.comparing(StudentGrade::getName);
                break;
            default:
                comparator = Comparator.comparingInt(StudentGrade::getTotal).reversed();
        }
        List<StudentGrade> sortedList = students.stream()
            .sorted(comparator)
            .collect(Collectors.toList());
        System.out.println("Stream API排序结果:");
        sortedList.forEach(System.out::println);
        System.out.println("------------------------");
    }
    private void displayResults(String title) {
        System.out.println(title + ":");
        students.forEach(System.out::println);
        System.out.println("------------------------");
    }
    public static void main(String[] args) {
        GradeSortSystem system = new GradeSortSystem();
        // 原始数据
        System.out.println("原始数据:");
        system.sortBySubject("id");  // 按学号升序
        System.out.println();
        // 各种排序方式
        system.sortByTotalScore();
        system.sortBySubject("chinese");
        system.sortBySubject("math");
        system.sortBySubject("english");
        System.out.println("使用Stream API排序:");
        system.sortWithStream("name");
    }
}

性能对比测试

import java.util.*;
public class SortPerformanceTest {
    public static void main(String[] args) {
        int[] sizes = {1000, 10000, 100000};
        for (int size : sizes) {
            System.out.println("\n=== 数组大小: " + size + " ===");
            // 生成随机数据
            int[] arr1 = generateRandomArray(size);
            int[] arr2 = arr1.clone();
            int[] arr3 = arr1.clone();
            int[] arr4 = arr1.clone();
            // 测试不同排序算法的性能
            testSort("Arrays.sort()", () -> Arrays.sort(arr1));
            testSort("冒泡排序", () -> SortingAlgorithmsDemo.bubbleSort(arr2));
            testSort("快速排序", () -> SortingAlgorithmsDemo.quickSort(arr3, 0, arr3.length - 1));
            testSort("归并排序", () -> SortingAlgorithmsDemo.mergeSort(arr4, 0, arr4.length - 1));
        }
    }
    private static int[] generateRandomArray(int size) {
        Random random = new Random();
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = random.nextInt(100000);
        }
        return arr;
    }
    private static void testSort(String name, Runnable sortMethod) {
        long startTime = System.nanoTime();
        sortMethod.run();
        long endTime = System.nanoTime();
        double duration = (endTime - startTime) / 1_000_000.0;
        System.out.printf("%-20s: %.2f ms%n", name, duration);
    }
}

选择建议：

1. 数据量小（<1000）：任何算法都可以
2. 数据量大（>10000）：使用快速排序或归并排序
3. 数据基本有序：插入排序效率高
4. 稳定性要求高：归并排序
5. 实际开发：优先使用Arrays.sort()或Collections.sort()

常用排序算法时间复杂度：

• 冒泡排序：O(n²)
• 选择排序：O(n²)
• 插入排序：O(n²)
• 快速排序：O(n log n)
• 归并排序：O(n log n)
• Arrays.sort()：O(n log n)

这些案例涵盖了从基础到高级的排序应用,你可以根据实际需求选择合适的实现方式。