Java对象排序

排序是计算机科学中的一个基本问题，它是将一组数据按照特定规则进行重新排列的过程。在Java中，对象排序是指对一个包含多个对象的集合进行排序操作。排序可以按照对象的某个属性进行，也可以按照对象的多个属性进行。

排序算法

Java标准库中提供了多种排序算法，常用的有冒泡排序、选择排序、插入排序、归并排序和快速排序等。这些排序算法都可以用于对象排序。

冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较相邻的两个元素，并按照大小交换它们的位置，直到整个列表排序完成。

public static <T extends Comparable<? super T>> void bubbleSort(T[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (array[j].compareTo(array[j + 1]) > 0) {
                T temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

选择排序

选择排序是一种简单的排序算法，它每次遍历列表找到最小元素，并将其与当前位置的元素交换位置，直到整个列表排序完成。

public static <T extends Comparable<? super T>> void selectionSort(T[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (array[j].compareTo(array[minIndex]) < 0) {
                minIndex = j;
            }
        }
        T temp = array[minIndex];
        array[minIndex] = array[i];
        array[i] = temp;
    }
}

插入排序

插入排序是一种简单的排序算法，它逐个将元素插入到已排序序列中的正确位置，直到整个列表排序完成。

public static <T extends Comparable<? super T>> void insertionSort(T[] array) {
    int n = array.length;
    for (int i = 1; i < n; i++) {
        T key = array[i];
        int j = i - 1;
        while (j >= 0 && array[j].compareTo(key) > 0) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;
    }
}

归并排序

归并排序是一种分治的排序算法，它将一个列表递归地分成两个子列表，然后将两个子列表合并成一个有序列表，直到整个列表排序完成。

public static <T extends Comparable<? super T>> void mergeSort(T[] array) {
    if (array.length > 1) {
        int mid = array.length / 2;
        T[] leftArray = Arrays.copyOfRange(array, 0, mid);
        T[] rightArray = Arrays.copyOfRange(array, mid, array.length);
        mergeSort(leftArray);
        mergeSort(rightArray);
        merge(array, leftArray, rightArray);
    }
}

private static <T extends Comparable<? super T>> void merge(T[] array, T[] leftArray, T[] rightArray) {
    int i = 0, j = 0, k = 0;
    while (i < leftArray.length && j < rightArray.length) {
        if (leftArray[i].compareTo(rightArray[j]) <= 0) {
            array[k++] = leftArray[i++];
        } else {
            array[k++] = rightArray[j++];
        }
    }
    while (i < leftArray.length) {
        array[k++] = leftArray[i++];
    }
    while (j < rightArray.length) {
        array[k++] = rightArray[j++];
    }
}

快速排序

快速排序是一种分治的排序算法，它选择一个基准元素，并将列表分成小于基准元素和大于基准元素的两个子列表，然后递归地对两个子列表进行排序，直到整个列表排序完成。

public static <T extends Comparable<? super T>> void quickSort(T[] array) {
    quickSort(array, 0, array.length - 1);
}

private