重用代码 - Java

Question

有没有办法在这些函数中重用数组代码的迭代：

public static double[] ln(double[] z) {
    // returns  an array that consists of the natural logarithm of the values in array z
    int count = 0;

    for (double i : z){
        z[count] = Math.log(i);
        count += 1;
    }
    return z;
}


public static double[] inverse(double[] z) {
    //  returns  an array that consists of the inverse of the values in array z
    int count = 0;

    for (double i : z){
        z[count] = Math.pow(i,-1);
        count += 1;
    }
    return z;
}

Answer 1

是的，使用 http://en.wikipedia.org/wiki/Strategy_pattern 但它可能会太过分了。重复的迭代和 count++ 看起来并没有那么糟糕。

Answer 2

您的代码与您的评论不符。

public static double[] ln(double[] z) {
    // returns  an array that consists of the natural logarithm of the values in array z
    double[] r = new double[z.length];
    for(int i=0;i<z.length;i++) r[i] = Math.log(z[i]);
    return r;
}

public static double[] inverse(double[] z) {
    //  returns  an array that consists of the inverse of the values in array z
    double[] r = new double[z.length];
    for(int i=0;i<z.length;i++) r[i] = 1/z[i];
    return r;
}

您可以使用策略模式使循环变得通用，但这有三个缺点。

• 代码更难阅读。
• 代码更长、更复杂。
• 执行速度要慢很多倍。

Math.pow(x, -1) 比 1/x 昂贵许多倍，并且可能产生更多舍入误差。

Answer 3

这是重用循环的方法。下面是一个示例：

public interface MathOperation {
   public double f(double value);
}

---

public class Invert implements MathOperation {
   public double f(double value) {
     return Math.pow(value, -1);
   }
}

---

public class Log implements MathOperation {
   public double f(double value) {    
     return Math.log(value);
   }
}

---

private static void calculateOnArray(double[] doubles, MathOperation operation) {
  int count = 0;

  for (double i : doubles){
    doubles[count] = operation.f(i);
    count += 1;
  }
}

public static double[] ln(double[] z) {
  calculateOnArray(z, new Log());
  return z;
}

public static double[] inverse(double[] z) {
  calculateOnArray(z, new Invert());
  return z;
}

---

注意 - 这不是命令模式，也不是真实的实现 策略模式。它接近策略，但为了避免进一步的否决，我保留该模式未命名;-)

Answer 4

没有太多的重用，但这里有两点 - 首先，永远不要使用 i 作为数组值，按照惯例，它是迭代器，如果你这样做，你会让人们感到困惑。其次，您最好在此处使用 for 循环而不是 for every 循环，这将消除您的手动“count”变量。

我还会在返回数组之前创建一个数组的副本，您实际上正在更改此处传递的参数，如果其他人看到您的方法签名可能不是他们所期望的。我希望具有这样的返回类型的方法能够保持原始参数不变（因为返回与我已经引用的值相同的值是没有意义的！）

Answer 5

在支持闭包、lambda 表达式或可传递块的语言中（例如 Ruby），您可以简洁地执行此操作。在 Java 中，您可以通过定义一个带有作为回调调用的方法的接口来模拟这一点。在使用它的地方，您可以使用该接口创建一个匿名类。看起来有点麻烦：

public interface Calculation {
    double calculate(double x);
}

public static double[] calcArray(double[] z, Calculcation calc) {
    int count = 0;

    for (double i : z){
        z[count] = calc.calculate(i);
        count += 1;
    }
    return z;
}

public static double[] ln(double[] z) {
    return calcArray(z, new Calculation() {
        double calculate(double x) {
            return Math.log(x);
        }
    });
}

public static double[] inverse(double[] z) {
    return calcArray(z, new Calculation() {
        double calculate(double x) {
            return Math.pow(x, -1);
        }
    });
}

Answer 6

如果您使用函数式编程，则可以重用它。有很多图书馆都为您提供了大量此类内容。在这个例子中，我只是使用了 Guava (http://code.google.com/p/guava-libraries/)，但是像 Function Java (http://functionjava.org/) 这样的库也可以工作。

函数式编程的主要好处之一是能够抽象出算法，以便您可以在需要的地方重用该算法。对于您的情况，您的算法本质上是这样的：

1. 对于列表中的每个元素
2. 对该元素执行 x 操作
3. 返回新列表

技巧是能够根据您想要执行的操作传入新操作来代替“x” 。在函数式编程的世界中，我们创建一个称为“函子”的对象，它实际上只是将函数封装在对象中的一种方式。 （如果 Java 有闭包，这会更容易，但这就是我们所拥有的。）

无论如何，这里有一些代码可以完成您想要的操作：

Class: Inverse

import com.google.common.base.Function;

public class Inverse implements Function
{
    @Override
    public Double apply(Double arg0)
    {
        return Math.pow(arg0, -1);
    }
}

Class: Logarithm

import com.google.common.base.Function;

public class Logarithm implements Function
{
    @Override
    public Double apply(Double arg0)
    {
        return Math.log(arg0);
    }
}

Class: Driver

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.Test;

import com.google.common.collect.Collections2;

public class Driver
{
    @Test
    public void testInverse()
    {
        List initialValues = Arrays.asList(new Double[] {1.0, 2.0, 3.0});

        List logValues = new ArrayList(Collections2.transform(initialValues, new Inverse()));

        assertEquals(3, logValues.size());

        assertEquals(Double.valueOf(1.0), logValues.get(0), 0.01);
        assertEquals(Double.valueOf(0.5), logValues.get(1), 0.01);
        assertEquals(Double.valueOf(0.333), logValues.get(2), 0.01);

    }
}

Driver 类只包含一个测试用例，但它确实说明了上面定义的函子的用法。您会注意到上面的 testInverse 方法中使用了名为 Collections2.transform 的方法。您可以在此处找到此方法的文档：

http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/collect/Collections2。 html#transform%28java.util.Collection,%20com.google.common.base.Function%29

本质上，此方法的作用是抽象出遍历列表并将某些函数应用于列表中每个元素的算法该列表 - 您所要做的就是应用要执行的功能。因此，在这种情况下，我向该方法传递一个双精度列表和一个函子（逆）。它给我返回一个新列表，其中包含初始列表中每个值的倒数。如果您希望对每个值进行记录，请将不同的函子传递给转换方法。

这种类型的编程确实有一点学习曲线，但对于您想要执行的代码重用类型来说，它绝对是很棒的。通过利用现有的库（如 Guava），您可以使代码更容易编写。请注意，我编写的代码实际上比您编写的代码要容易一些，因为在执行数学函数时我不必处理列表/数组 - 我只需在一个元素上执行；变换函数负责在整个列表中应用该函数。

Answer 7

是的，正如这里的几个例子所示。但如果这是真正的问题而不是一种极端的简化，那么创建三个具有继承和重载的类以节省编写一个 FOR 语句在我看来似乎正朝着错误的方向前进。您正在编写二十行代码，以节省重复一行代码的次数。有什么收获？

如果在现实生活中，由于某种原因，迭代数据的过程要复杂得多——如果它不仅仅是循环遍历数组，而且我不知道，还有一些在数据库中查找内容并提交网络的复杂过程服务请求并执行一个充满复杂计算的页面来查找下一个元素 - 那么我的答案会有所不同。