java排序及泛型

一、用泛型实现快排，可以传入不通类型进行排序，比如String数组，Integer数组。

/**
 * 快速排序
 *
 * @author chx
 *
 */
public class QuickSort {
    /**
     * 数组内数值的交换函数
     *
     * @param arr
     *            原数组
     * @param leftIndex
     *            左索引
     * @param rightIndex
     *            右索引
     */
    private static <T> void change(T[] arr, int leftIndex, int rightIndex) {
        T temp = arr[leftIndex];
        arr[leftIndex] = arr[rightIndex];
        arr[rightIndex] = temp;
    }

    public static <T> void sort(T[] arr, int left, int right) {
        if (right < left) {
            // 查找区间内，外的返回
            return;
        }
        T flag = arr[left];// 哨兵的值
        int indexLeft = left;// 本轮查找需要的左索引
        int indexRight = right;// 本轮查找需要的右索引

        while (indexLeft != indexRight) {
            // 开始从右向左找，找比哨兵小的值。或者直到遇到左索引
            while (Integer.parseInt(arr[indexRight].toString()) >= Integer.parseInt(flag.toString())
                    && indexLeft < indexRight) {
                indexRight--;
            }
            // 从左向右找，找到比哨兵大的值，或者直到遇到右索引
            while (Integer.parseInt(arr[indexLeft].toString()) <= Integer.parseInt(flag.toString())
                    && indexLeft < indexRight) {
                indexLeft++;
            }
            if (indexLeft < indexRight) {
                // 找到了，交换
                change(arr, indexLeft, indexRight);
            }
        }
        // 此时一遍探索结束，将哨兵和当前的值进行交换，并进行分区探索
        change(arr, left, indexLeft);
        // 右边探索
        sort(arr, indexRight + 1, right);
        // 左边探索
        sort(arr, left, indexLeft - 1);
    }
}

二、利用Arrays.sort()进行排序

　　突然有个同学咨询Arrays.sort用法，正好在此记录。

　　1.简介：有的时候不愿意去写排序程序，可以利用java自带的Arrays.sort()方法。

2.使用规则：总结为，基本数据类型直接放，引用数据类型需要利用实现了Comparator<T>的对象辅助排序。

3.具体用法：

package mianshi;

import java.util.Arrays;
import java.util.Comparator;

public class SortTest implements Comparator<SortTest> {
    private int sortValue;

    public int getSortValue() {
        return sortValue;
    }

    public void setSortValue(int sortValue) {
        this.sortValue = sortValue;
    }

    public static void main(String[] args) {
        SortTest[] list = new SortTest[5];

        for (int i = 0; i < list.length; i++) {
            list[i] = new SortTest();
            list[i].setSortValue(i*2);
        }

        Comparator<SortTest> cmp = new SortTest();
        Arrays.sort(list, cmp);

        for (int i = 0; i < list.length; i++) {
            System.out.print(list[i].getSortValue() + " ");
        }
    }

    @Override
    public int compare(SortTest o1, SortTest o2) {
        if (o1.getSortValue() > o2.getSortValue()) {
            return -1;
        }else if(o1.getSortValue() < o2.getSortValue()) {
            return 1;
        }

        return 0;
    }
}

返回值规则:compare是实现对比的方法，正数-大于，0-等于，负数-小于。所以本程序是倒序排序。

tips:感兴趣的可以百度下compare的实现原理、算法选择。有很多需要了解的内容。