如何将Java排序算法耗时对比程序改写为面向对象模式并解决报错

报错原因 #

• Java的main方法是程序固定入口，强制要求static修饰，你移除所有static修饰符后，静态的main方法无法直接访问非静态的类成员，这是最核心的报错原因
• 创建类实例必须用new关键字调用构造方法，如果你写的是SortingExercise OO;没有加= new SortingExercise();也会触发未初始化/空指针报错
• 数组长度常量属于全局固定值，不需要每个类实例单独存储，强行移除static反而不合理，保留static final修饰不会破坏OOP结构

改造步骤 #

1. 保留main方法的static修饰，保留所有数组长度常量的static final修饰
2. 仅移除randomInts、selectionSort两个业务方法的static修饰，改为普通实例方法
3. 在main方法开头实例化SortingExercise类的对象：SortingExercise oo = new SortingExercise();
4. 所有原代码中调用randomInts、selectionSort的位置，加上oo.前缀即可

改造后完整可运行代码 #

import java.util.Arrays;

public class SortingExercise {
    // 定义数组长度常量
    final static int CONST100 = 100000; // 待排序数组长度：10万
    final static int CONST10 = 10000; // 待排序数组长度：1万
    final static int CONST1 = 1000; // 待排序数组长度：1千
    final static int CONSTMIL = 1000000; // 待排序数组长度：100万

    /*
     * 生成填充了随机整数的数组
     * @param count : 生成的数组长度
     */
    private int[] randomInts(int count) {
        int[] numbers = new int[count];
        for (int i = 0; i < count; i++)
            numbers[i] = (int)(Integer.MAX_VALUE * Math.random());
        return numbers;
    }

    /*
     * 用选择排序算法对整数数组排序
     */
    private void selectionSort(int[] numbers) {
        for (int end = numbers.length-1; end > 0; end-- ) {
            int maxloc = 0;
            for (int i = 1; i <= end; i++) {
                if (numbers[i] > numbers[maxloc])
                    maxloc = i;
            }
            int temp = numbers[end];
            numbers[end] = numbers[maxloc];
            numbers[maxloc] = temp;
        }
    }

    public static void main(String[] args) {
        SortingExercise oo = new SortingExercise();
        double startTime;
        double runTime;
        int[] Array1;
        int[] Array2;

        // 第一轮测试：1000个元素
        Array1 = oo.randomInts(CONST1);
        Array2 = Arrays.copyOf(Array1, CONST1);

        // 分别用选择排序和内置排序方法对相同的1000元素数组排序，打印耗时对比
        startTime = System.currentTimeMillis();
        oo.selectionSort(Array1);
        runTime = System.currentTimeMillis() - startTime;
        System.out.println(runTime + " 毫秒（1000元素数组，选择排序）");

        startTime = System.nanoTime();
        Arrays.sort(Array2);
        runTime = System.nanoTime() - startTime;
        System.out.println(runTime/1000000 + " 毫秒（1000元素数组，内置Arrays.sort方法）");
        System.out.println();

        // 第二轮测试：10000个元素
        Array1 = oo.randomInts(CONST10);
        Array2 = Arrays.copyOf(Array1, CONST10);

        startTime = System.currentTimeMillis();
        oo.selectionSort(Array1);
        runTime = System.currentTimeMillis() - startTime;
        System.out.println(runTime + " 毫秒（10000元素数组，选择排序）");

        startTime = System.currentTimeMillis();
        Arrays.sort(Array2);
        runTime = System.currentTimeMillis() - startTime;
        System.out.println(runTime + " 毫秒（10000元素数组，内置Arrays.sort方法）");
        System.out.println();

        // 第三轮测试：100000个元素
        Array1 = oo.randomInts(CONST100);
        Array2 = Arrays.copyOf(Array1, CONST100);

        startTime = System.currentTimeMillis();
        oo.selectionSort(Array1);
        runTime = System.currentTimeMillis() - startTime;
        System.out.println(runTime + " 毫秒（100000元素数组，选择排序）");

        startTime = System.currentTimeMillis();
        Arrays.sort(Array2);
        runTime = System.currentTimeMillis() - startTime;
        System.out.println(runTime + " 毫秒（100000元素数组，内置Arrays.sort方法）");
        System.out.println();

        // 可选测试：仅用内置排序测试100万元素数组
        Array1 = oo.randomInts(CONSTMIL);
        startTime = System.currentTimeMillis();
        Arrays.sort(Array1);
        runTime = System.currentTimeMillis() - startTime;
        System.out.println(runTime + " 毫秒（100万元素数组，内置Arrays.sort方法）");
    }
}

内容的提问来源于stack exchange，提问作者Josh Ratliff