日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。

冒泡排序

    /**
     * <strong>冒泡排序法</strong>
     *
     * 使用类似于冒泡的方法，将数组中的较小的元素冒泡到最后，从而实现对于数据从大到小的排列顺序
     *
     * 使用第一个元素，逐个同后面的元素比较，如果第一个元素小，则上浮，同比较的元素替换位置，将最大的元素替换到第一位
     * 然后继续从第二个元素开始，逐个同后面的元素比较，将第二大的元素排在第二位，直至排序到最后一位，就可以形成从大到小的排列顺序
     *
     * @param numbers 需要排序的数组
     */
    public static void bubbleSort(int[] numbers) {
        int temp, size = numbers.length;

        for (int i = 0; i < size - 1; i++) {
            for (int j = i + 1; j < size; j++) {
                if (numbers[i] < numbers[j]) {//如果前面的元素小，则上浮
                    temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                }
            }
        }
    }

快速排序

    /**
     * <strong>快速排序法</strong>
     *
     * <ul>
     * <li>从数列中挑出一个元素，称为“基准”</li>
     * <li>重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，
     * 该基准是它的最后位置。这个称为分割（partition）操作。</li>
     * <li>递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。</li>
     * </ul>
     *
     * @param numbers 需要排序的数组
     * @param start 开始位置
     * @param end 结束位置
     */
    public static void quickSort(int[] numbers, int start, int end) {
        if (start < end) {
            int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）
            int temp; // 记录临时中间值
            int i = start, j = end;
            do {
                while ((numbers[i] < base) && (i < end))//在不超过结束位之前的数字小于基准数字的，不进行处理
                    i++;
                while ((numbers[j] > base) && (j > start))//在不小于开始位之前的数字大于基准数字的，不进行处理
                    j--;
                if (i <= j) {//一旦到达此处，则认为i位置的值大于等于基准值，j位置的值小于等于基准值，则替换i和j位置的值
                    temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                    i++;
                    j--;
                }
            } while (i <= j);//在开始位置和结束位置之间
            if (start < j)//如果开始位置小于小于j判断的位置，则比较这两个区段内的数字，进行位置对换
                quickSort(numbers, start, j);
            if (end > i)//如果结束位置大于i判断的位置，则比较这两个区段的位置，进行位置对换
                quickSort(numbers, i, end);
        }
    }

选择排序

    /**
     * 选择排序
     * <ul>
     * <li>在未排序序列中找到最小元素，存放到排序序列的起始位置</li>
     * <li>再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。</li>
     * <li>以此类推，直到所有元素均排序完毕。</li>
     * </ul>
     *
     * @param numbers 需要排序的数组
     */
    public static void selectSort(int[] numbers) {
        int temp, size = numbers.length;
        for (int i = 0; i < size; i++) {//从第一个元素开始定位
            int k = i;
            for (int j = size - 1; j >i; j--)  {//从最后一个元素开始寻找
                if (numbers[j] < numbers[k])  k = j;//如果被寻找的元素，小于定位的元素，则替换二者的位置
            }
            temp = numbers[i];
            numbers[i] = numbers[k];
            numbers[k] = temp;
        }
    }

插入排序

    /**
     * 插入排序<br/>
     * <ul>
     * <li>从第一个元素开始，该元素可以认为已经被排序</li>
     * <li>取出下一个元素，在已经排序的元素序列中从后向前扫描</li>
     * <li>如果该元素（已排序）大于新元素，将该元素移到下一位置</li>
     * <li>重复步骤3，直到找到已排序的元素小于或者等于新元素的位置</li>
     * <li>将新元素插入到该位置中</li>
     * <li>重复步骤2</li>
     * </ul>
     *
     * @param numbers
     */
    public static void insertSort(int[] numbers) {
        int size = numbers.length, temp, j;
        for(int i=1; i<size; i++) {
            temp = numbers[i];
            for(j = i; j > 0 && temp < numbers[j-1]; j--)
                numbers[j] = numbers[j-1];
            numbers[j] = temp;
        }
    }

归并排序

    /**
     * 归并排序<br/>
     * <ul>
     * <li>申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列</li>
     * <li>设定两个指针，最初位置分别为两个已经排序序列的起始位置</li>
     * <li>比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置</li>
     * <li>重复步骤3直到某一指针达到序列尾</li>
     * <li>将另一序列剩下的所有元素直接复制到合并序列尾</li>
     * </ul>
     *
     * @param numbers
     */
    public static void mergeSort(int[] numbers) {
        sort(numbers, 0, numbers.length - 1);
    }

    public static void sort(int[] numbers, int left, int right) {
        if (left >= right)
            return;
        // 找出中间索引
        int center = (left + right) / 2;
        // 对左边数组进行递归
        sort(numbers, left, center);
        // 对右边数组进行递归
        sort(numbers, center + 1, right);
        // 合并
        merge(numbers, left, center, right);
        System.out.println(Arrays.toString(numbers));
    }
    /**
     * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
     *
     * @param numbers
     *            数组对象
     * @param left
     *            左数组的第一个元素的索引
     * @param center
     *            左数组的最后一个元素的索引，center+1是右数组第一个元素的索引
     * @param right
     *            右数组最后一个元素的索引
     */
    public static void merge(int[] numbers, int left, int center, int right) {
        // 临时数组
        int[] tmpArr = new int[numbers.length];
        // 右数组第一个元素索引
        int mid = center + 1;
        // third 记录临时数组的索引
        int third = left;
        // 缓存左数组第一个元素的索引
        int tmp = left;
        while (left <= center && mid <= right) {
            // 从两个数组中取出最小的放入临时数组
            if (numbers[left] <= numbers[mid]) {
                tmpArr[third++] = numbers[left++];
            } else {
                tmpArr[third++] = numbers[mid++];
            }
        }
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
        while (mid <= right) {
            tmpArr[third++] = numbers[mid++];
        }
        while (left <= center) {
            tmpArr[third++] = numbers[left++];
        }
        // 将临时数组中的内容拷贝回原数组中
        // （原left-right范围的内容被复制回原数组）
        while (tmp <= right) {
            numbers[tmp] = tmpArr[tmp++];
        }
    }

归并算法因为需要创建新的数组，然后在排序完成后进行合并，因此会占用更多的内存空间，且随着数组内元素增长，数组拷贝和合并也会占用更多的时间。

参考：
Java实现几种常见排序方法