java中如何排大小

一、JAVA中如何排大小

在Java中，我们可以通过多种方式实现排大小的功能，包括使用Java的内置排序函数Collections.sort()、Arrays.sort()、使用冒泡排序算法、选择排序算法、插入排序算法、快速排序算法、归并排序算法等。这些方法各有优势，适用于不同的情况和需求。其中，Java的内置排序函数Collections.sort()和Arrays.sort()使用的是改进的快速排序算法，效率较高，是我们在实际编程中最常用的排序方式。下面，我们将详细介绍这些排序方法的使用和实现。

二、使用JAVA的内置排序函数

1、Collections.sort()

Collections.sort()是Java中的一个内置函数，用于对List类型的集合进行排序。对于基本数据类型，它可以直接进行排序，而对于自定义的对象类型，则需要实现Comparable接口或者提供Comparator接口的实现。

首先，我们来看一下如何对基本数据类型的List进行排序：

import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(5);
        list.add(20);
        list.add(1);
        Collections.sort(list);
        System.out.println(list);
    }
}

在上述代码中，我们先创建了一个ArrayList对象，并添加了四个元素。然后，我们通过调用Collections.sort()方法对其进行排序。运行结果为：[1, 5, 10, 20]。

2、Arrays.sort()

Arrays.sort()是Java中用于对数组进行排序的内置函数。和Collections.sort()一样，对于基本数据类型，它可以直接进行排序，而对于自定义的对象类型，则需要实现Comparable接口或者提供Comparator接口的实现。

下面是一个使用Arrays.sort()对基本数据类型数组进行排序的示例：

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] arr = {10, 5, 20, 1};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

在上述代码中，我们先创建了一个整型数组，并添加了四个元素。然后，我们通过调用Arrays.sort()方法对其进行排序。运行结果为：[1, 5, 10, 20]。

三、使用冒泡排序算法

冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

下面是一个使用冒泡排序对数组进行排序的示例：

public class BubbleSort {
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

在上述代码中，我们首先定义了一个sort方法，接收一个整型数组作为参数。然后，我们使用两层循环进行冒泡排序。外层循环控制排序的轮数，内层循环控制每轮比较的次数。如果当前元素大于下一个元素，我们就交换他们的位置。

四、使用选择排序算法

选择排序是一种简单直观的排序算法。它的工作原理是首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

下面是一个使用选择排序对数组进行排序的示例：

public class SelectionSort {
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
}

在上述代码中，我们首先定义了一个sort方法，接收一个整型数组作为参数。然后，我们使用两层循环进行选择排序。外层循环控制排序的轮数，内层循环控制每轮比较的次数。我们首先假设当前元素是最小的，然后与后面的元素进行比较，如果发现有更小的元素，我们就更新最小元素的索引。在每轮排序结束后，我们将最小元素与当前元素进行交换。

五、使用插入排序算法

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

下面是一个使用插入排序对数组进行排序的示例：

public class InsertionSort {
    public static void sort(int[] arr) {
        for (int i = 1; i < arr.length; 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;
        }
    }
}

在上述代码中，我们首先定义了一个sort方法，接收一个整型数组作为参数。然后，我们使用一层循环进行插入排序。我们先将当前元素存储到一个变量key中，然后从当前元素的前一个元素开始向前扫描，如果前一个元素大于当前元素，我们就将前一个元素向后移动一位，直到找到一个元素不大于当前元素。最后，我们将当前元素插入到找到的位置。

六、使用快速排序算法

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

下面是一个使用快速排序对数组进行排序的示例：

public class QuickSort {
    public static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);
            sort(arr, low, pivot - 1);
            sort(arr, pivot + 1, high);
        }
    }
    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[low];
        while (low < high) {
            while (low < high && arr[high] >= pivot) high--;
            arr[low] = arr[high];
            while (low < high && arr[low] <= pivot) low++;
            arr[high] = arr[low];
        }
        arr[low] = pivot;
        return low;
    }
}

在上述代码中，我们首先定义了一个sort方法，接收一个整型数组和两个索引作为参数。然后，我们使用递归的方式进行快速排序。我们先找到一个基准元素，并将所有小于基准元素的元素移到基准元素的左边，所有大于基准元素的元素移到基准元素的右边。然后，我们对基准元素左边和右边的子序列分别进行快速排序。

七、使用归并排序算法

归并排序是创建在归并操作上的一种有效的排序算法，效率为O(n log n)，1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。

下面是一个使用归并排序对数组进行排序的示例：

public class MergeSort {
    public static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            sort(arr, low, mid);
            sort(arr, mid + 1, high);
            merge(arr, low, mid, high);
        }
    }
    private static void merge(int[] arr, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low, j = mid + 1, k = 0;
        while (i <= mid && j <= high) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = arr[i++];
        }
        while (j <= high) {
            temp[k++] = arr[j++];
        }
        for (int x = 0; x < temp.length; x++) {
            arr[x + low] = temp[x];
        }
    }
}

在上述代码中，我们首先定义了一个sort方法，接收一个整型数组和两个索引作为参数。然后，我们使用递归的方式进行归并排序。我们先将数组分成两半，然后对每一半进行排序，最后将排序好的两半合并在一起。合并操作是通过创建一个临时数组，然后将两个已排序的子序列中的元素依次比较并放入临时数组，最后将临时数组中的元素复制回原数组。

以上就是Java中排大小的几种常用方法，希望对你有所帮助。