Question

我有一个名为sortTest()的方法，该方法接受一个数字和一个sortName()。它将接受的数字将成为创建的数组的大小，而sortName()应该是它将执行的排序的名称。

例如，如果我有sortTest(5, bubbleSort)，则应创建一个由5个随机数组成的数组，然后通过冒泡排序将该5个数组进行取整。这是我的代码：

public static final int loopSize = 16; 
    public static int[] makeArray(int n) { 
        int[] array = new int[n]; 

        for(int d = 0; d < loopSize; d++ ) { 

            Random r = new Random(); 

            for(int i = 0; i < n; i++) { 

                for(int k = 0; k < n; k++) { 

                    array[k] = (int)( Math.random()* 1000); 

                } 

            } 

        } 

        return array; 

    } 

public static void sortTest(int num , sortName() ) { 

    long Finaltime []; 

    for(int k = 0; k < loopSize; k++ ) { 

        arr = makeArray(num); 

        long startTime = System.nanoTime(); 

        sortName(arr); 

        endTime = System.nanoTime(); 

        totalTime = endTime - startTime; 

    } 

}

Answer 1

有很多不同的方法可以做到这一点。您可能要查看功能文档：https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

在您的情况下，您可能希望将顶级功能更改为其他功能的使用者。

类似的东西：

public static void sortTest(int num, BiFunction<Integer, Integer, Integer> sortFunction) {...}

（在这种情况下，它是BiFunction或称为sortFunction.apply(int, int) returning an int

在Java中，功能接口有些“笨拙”，但它们可以正常工作（并且以一种或另一种形式存在已经相当一段时间了）。在Java 1.8及更高版本中，对lambda有了更多的正式支持，从而使它们更加可用。

从根本上讲，这只是一个碰巧是函数的接口。然后，您可以创建具有不同名称的排序函数：

BiFunction<Integer, Integer, Integer> ascending = (a,b) -> { ... return sort; //-1 0 1};
BiFunction<Integer, Integer, Integer> descending = (a,b) -> { return ascending.apply(b, a) };
...etc...

然后可以将这些传递给您的静态方法：

...
YourClass.sortTest(10, ascending)
...

希望这会为您指明正确的方向。看起来您是Java的新手，不要害怕提出问题。

Answer 2

注意：此答案基于Java 8和更高版本。这不适用于Java 7，因为Java 7不支持Lambda

定义SortType接口

interface SortType {
    void sortName(int[] data);
}

编写测试用例

public class Test {
    public static final int loopSize = 16;

    public static int[] makeArray(int n) {
        int[] array = new int[n];
        for (int d = 0; d < loopSize; d++) {
            Random r = new Random();
            for (int i = 0; i < n; i++) {
                for (int k = 0; k < n; k++) {
                    array[k] = (int) (Math.random() * 1000);
                }
            }
        }
        return array;
    }

    // Pass functional SortType interface
    public static void sortTest(int num, SortType sortType) {

        long Finaltime[];
        for (int k = 0; k < loopSize; k++) {
            int[] arr = makeArray(num);
            long startTime = System.nanoTime();
            sortType.sortName(arr);
            long endTime = System.nanoTime();
            long totalTime = endTime - startTime;
        }
    }
}

使用主要方法执行测试用例

public static void main(String[] args) {
        // define which algorithm need to call
        SortType bubbleSort = (int[] data) -> Arrays.sort(data);
        SortType bubbleSortOnlyLastThree = (int[] data) -> Arrays.sort(data, 2, 5);
        sortTest(5, bubbleSort);
        sortTest(5, bubbleSortOnlyLastThree);
    }

Answer 3

否，您不能将sortName()方法作为参数传递给另一个方法（至少不是那样），也不应该。我认为您的情况最好的解决方案是使用静态方法。

在Java中，直接调用静态方法，而无需创建包含该方法的类的实例（对象）（有关更多详细信息，请参见this问题的答案）。在这种情况下，您可以这样声明sortName()：

public MyClass {
    public static void sortName(long[] array) {
        //your code here
    }
}

然后，每当需要在MyClass之外调用它时，只需使用以下语法即可：MyClass.sortName(myArray)。在您的代码中，它看起来像这样：

public static void sortTest(int num) { 
    //...
    MyClass.sortName(arr);
    //...
}

有没有办法让一个函数在其参数中调用另一个函数？

3 个答案: