排序方法自动测试（只需一行代码）

上项目地址

https://gitee.com/yan-jiadou/study/tree/master/Java%E5%8A%A8%E6%89%8B%E5%81%9A%E4%B8%80%E5%81%9A/src/main/java/SortStudy

测试方法已经写了，采用的是自动测试，你只需调用即可，非常简单，这样我们的精力就可以放在SortCore的算法实现上了，这里的自动测试自带数据比对功能，用来测试你的排序方法实现的对不对，如果结果有问题，会返回false。

一.目的

有人说，排序方法我学了，但就是写不出来，就算写出来了，才发现根本用不上，因为写的太窄了，只能对数字进行排序。
我就是这样的人，最近复习算法知识的时候，我在想，能不能将自己学到的排序方法做出一个泛型排序合集工具，将各种排序合并起来，形成这样的一个工具方法：

/**
     * 排序方法调用
     * @param in
     * @param sortType maoPao--冒泡排序  insert--插入排序
     *                 shell--希尔排序   quick--快速排序
     *                 merge--归并排序   heap--堆排序
     *                 counting--计数排序
     * @return 返回排序后的结果
     */
    public static <T extends Comparable> Object[] Sort(T[] in,String sortType){
        if(sortType.equals("maoPao")){
            return SortCore.maoPaoSort(in);
        }
        if(sortType.equals("insert")){
            return SortCore.InsertionSort(in);
        }
        if(sortType.equals("shell")){
            return SortCore.ShellSort(in,in.length-1);
        }
        if(sortType.equals("quick")){
            return SortCore.quickSort(in,0,in.length-1);
        }
        if(sortType.equals("merge")){
            return SortCore.mergeSort(in,0,in.length-1);
        }
//        if(sortType.equals("heap")){
//            return new SortCore.Heap().Heapsort(null,in,in.length);
//        }

        return null;
    }

这样我就可以想用那种排序就用那种排序，也方便复习排序方法和优化学习，而不是分散的学习。

二.实现

带着这样的想法，我开始动手了，我将各种排序的实现放在一个类里面，供其他类调用，然后写个工具方法简化我们的调用操作。
好了，现在排序写好了，下面是如何测试，如果手动创建数组进行测试，麻烦程度可想而知，又费时间，于是我写出了一个随机数组自动生成器来帮我进行数组创建的工作：

 /**
     * 随机数组生成器，此方法可以生成普通数字类型,浮动数字类型 字符串类型的数组
     * 推荐使用：整数类型 Integer 浮动数类型 Double 字符串类型 String
     * @param type 元素类型
     * @param count 数组大小
     * @param <T> 泛型类型
     * @return 返回生成后的数组
     */
    public static <T extends Comparable> Object[] makeRandomArray(T type,Integer count) throws Exception {
        Object[] result=new Object[count];
        Class cl=type.getClass();
        Constructor[] constructors=cl.getDeclaredConstructors();
        Constructor constructor=null;
        for(Constructor constructor1:constructors){
            Class[] types = constructor1.getParameterTypes();
            if(types.length==1&&types[0]==String.class){
                constructor=constructor1;
                break;
            }
        }
        if(constructor==null){
            throw new Exception("此类型不支持生成随机类型");
        }
        for(int i=0;i<count;i++){
            String emuStr=null;
            double emu = 0;
            if(type.getClass()==String.class){
                int strLength=(int)(Math.random()*10);
                if(strLength<1){
                    strLength=1;
                }
                StringBuilder strBul=new StringBuilder();
                for(int j=0;j<strLength;j++){
                    int num=(int)(Math.random()*122);
                    while (num<97){
                        num=(int)(Math.random()*122);
                    }
                    char letter=(char) num;
                    strBul.append(letter);
                }
                emuStr=strBul.toString();
            }else{
                emu=(Math.random()*1000);
                emuStr= Double.toString(emu);
            }
            try{
                result[i]=constructor.newInstance(emuStr);
            }catch (Exception e){
                int emuInt=(int)emu;
                emuStr=Integer.toString(emuInt);
                result[i]=constructor.newInstance(emuStr);
            }
        }
        return  result;
    }

三.测试

人为测试比对非常麻烦，所以不如先用jdk自带的sort再排一遍，然后直接进行结果比对即可

 /**
     * 测方法用于测试排序方法
     * @param obj 需要测试的类型
     * @return 返回测试结果
     */
    public static <T extends Comparable> boolean sortTest(T obj,String type,int count){
        Object[] testResults = new Object[0];
        try{
            testResults=SortUtil.makeRandomArray(obj,count);
            Object[] arraySort=new Object[testResults.length];
            T[] result= (T[])Array.newInstance(obj.getClass(),testResults.length);
            int i=0;
            for(Object object:testResults){
                File file=new File("temp");
                if(file.exists()){
                    boolean flag=file.delete();
                }
                FileOutputStream fileOut = new FileOutputStream("temp");//定义文件字节输出流，源为temp
                ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);//定义对象字节输出流
                objectOut.writeObject(object);//将对象序列化信息写入源中
                objectOut.close();//关闭对象输出流
                FileInputStream fileIn = new FileInputStream("temp");//定义文件输入流，源为temp
                ObjectInputStream objectIn = new ObjectInputStream(fileIn);//定义对象字节输入流
                Object target = (T)objectIn.readObject();//将源中的对象读出得到object的克隆
                objectIn.close();//关闭对象输入流
                arraySort[i]=target;
                result[i]=(T)object;
                i++;
            }
            testResults=SortUtil.Sort(result,type);
            Arrays.sort(arraySort);

            for(int n=0;n<testResults.length;n++){
                if(!testResults[n].equals(arraySort[n])){
                    return false;
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return true;
    }

下面是主方法：

public static void main(String[] args) {
        System.out.println(sortTest(new Integer(10),"maoPao",10));
    }

没错，非常之简单，只需一行代码就可以完成自动测试！！！
结果：