Question

您好，我正在研究一种将函数（数学函数，例如f（x）= 3x + 2）应用于数组中每个元素的方法。我计划使该函数具有动态性，并能够根据示例进行更改，而无需更改代码（在不同公式之间切换）。我想将每个这些数学函数（公式）存储在单独的方法中，这将从一个主要方法-mapFunc中调用。 mapFunc将具有两个参数：正在通过公式运行的数组，以及包含所选数学函数的方法。这样一来，在主循环中调用mapFunc方法时，便可以编写mapFunc（myArray，myFormula（））。 myFormula是一种方法。在Java 8.0中，我可以使用lambda表达式和其他方法引用来将myFormula（）用作mapFunc（）中的参数，但是由于我使用的是仅完全支持Java7.0的Processing处理软件，因此无法使用lambda表达式和Java8.0中包含的其他功能。我想要一个这样的方法：

void mapFunction(float[][] data, myFormula()) {
    for (int i = 0; i < data.length; i++) {
        for(int j = 0; j < data[0].length; j++) {
        data[i][j] = myFormula(data[i][j]));
        }
    }
 }

在javascript中，我可以编写：

map(func) {
// Apply a function to every element of matrix
for (let i = 0; i < this.rows; i++) {
  for (let j = 0; j < this.cols; j++) {
    let val = this.data[i][j];
    this.data[i][j] = func(val);
  }
}

}

，然后使用myMatrix.map（double（））;

有用的链接： https://www.codementor.io/eh3rrera/using-java-8-method-reference-du10866vx-似乎不起作用。

Answer 1

在Java使用lambda之前，实现此目的的方法是使用Runnable之类的接口的匿名实例。像这样：

void doTheThing(Runnable r){
  r.run();
}

doTheThing(new Runnable(){
  public void run(){
    yourFunctionHere();
  }
});

或者，如果您的函数带有参数，则可以这样定义自己的接口：

interface ValueChanger{
  public float changeValue(float value);
}

然后，您可以创建一个接受ValueChanger实例的函数，如下所示：

void mapFunction(float[] data, ValueChanger valueChanger){
  data[0] = valueChanger.changeValue(data[0]);
}

您可以通过传入一个匿名实例来调用函数：

mapFunction(myArray, new ValueChanger(){
  public float changeValue(float value){
    return value * 2;
  }
});

Answer 2

但是我正在处理中，而在此版本中，我无法使用这些策略（语法错误）。也许我就是不明白这些方法引用如何工作

我不明白为什么lambda无法实现您的尝试。
如果可以使用Java 8编译器，则可以编写一个接受DoubleUnaryOperator参数的方法，该参数将是您需要将一个float映射到另一个float的函数，例如：

static void mapFunction(float[][] data, DoubleUnaryOperator function) {
    for (int i = 0; i < data.length; i++) {
        for (int j = 0; j < data[0].length; j++) {
            data[i][j] = (float) function.applyAsDouble(data[i][j]);
        }
    }
}

例如，此示例使用其正方形设置数组的元素：

public static void main(String[] args) {
    float[][] data = new float[][] {{0F,1F}, {2F,3F}};
    mapFunction(data, a->a*a);
    System.out.println(Arrays.deepToString(data));

}

输出：

[[0.0，1.0]，[4.0，9.0]]

如果您不能注意到使用Java 8或+版本或任何第三方库，则可以引入自己的接口来将浮点数映射到浮点数，并使用匿名类代替lambda，例如：

public interface FloatUnaryOperator  {
    float applyAsFloat(float operand);
}

static void mapFunction(float[][] data, FloatUnaryOperator function) {
    for (int i = 0; i < data.length; i++) {
        for (int j = 0; j < data[0].length; j++) {
            data[i][j] = function.applyAsFloat(data[i][j]);
        }
    }
}

public static void main(String[] args) {
    float[][] data = new float[][] {{0F,1F}, {2F,3F}};
    mapFunction(data, new FloatUnaryOperator() {

        @Override
        public float applyAsFloat(float operand) {
            return operand*operand;
        }
    });
    System.out.println(Arrays.deepToString(data));
}

将一个方法用作另一个方法的参数* Java处理*

2 个答案: