Question

我正在调用具有不同值的函数以获得特定结果。有什么方法可以减少这样的调用函数以提高Java的性能和可靠性？

func(1,6);
func(4,0);
func(2,7);
func(5,0);
func(3,0);


private static void func(int printer,int printing){
        if(printing == 0){
            for(int j=1;j<=7;j++){
                if(j!=printer){
                    arrayOdd.add(j);
                }
            }
        }else{
            for(int j=1;j<=7;j++){
                if(j!=printer && j!=printing)
                    arrayOdd.add(j);
            }
        }
    }

Answer 1

我的第一个提示是，您可以将功能替换为

private static void func(int printer,int printing){
    for(int j=1;j<=7;j++){
        if(j!=printer && j!=printing)
            arrayOdd.add(j);
    }
}

它的行为将相同。

第二个要点是，除非使用递归，否则重复调用函数不会对性能或可靠性产生任何影响，在这种情况下，您可能会遇到经典的堆栈溢出错误。为什么要/需要更少次调用该函数？

Answer 2

如果上面的函数可以是幂等的（相同的输入总是产生完全相同的输出），我建议使用记忆（https://java2blog.com/memoization-example-java/）。
看到函数输出后，您似乎只是从7位固定数组中删除传递的值。如果这就是您要寻找的全部，那么只需从数组中删除该元素并记住该函数即可。这样，该函数将仅执行最坏情况的64倍（64个不同组合，其中0、1、2、3、4、5、6、7的2位数字组合）

Answer 3

您可以将打印机的值和打印的值放在List或array中，但是只要没有逻辑保持输入，就需要手动输入参数。我的意思是这样

int final static THE_TIMES_YOU_CALLED_THE_FUNC=5;

List<int[]> list =new ArrayList<>(THE_TIMES_YOU_CALLED_THE_FUNC);
        list.add(new int []{1,6});
        list.add(new int []{4,0});
        list.add(new int []{2,7});
        list.add(new int []{5,0});
        list.add(new int []{3,0});

        for(int i=0;i<list.size();i++){
            funk(list.get(i)[0],list.get(i)[]);
        }
    }

    private static void func(int printer,int printing){
        if(printing == 0){
            for(int j=1;j<=7;j++){
                if(j!=printer){
                    arrayOdd.add(j);
                }
            }
        }else{
            for(int j=1;j<=7;j++){
                if(j!=printer && j!=printing)
                    arrayOdd.add(j);
            }
        }
    }

最后，编译器将调用func 5次，但我看不到我的灵魂上的优势，但是您最终希望一次编写func。

如何避免在Java中多次调用函数？

3 个答案: