java - 我正在尝试将一些 scala 代码转换为 Java 8 以删除新的 Lambda 和并行集合

Question

我花了 2 个小时尝试将一个示例从 Scala lang 转换为 Java lang，该示例在 scala 中很简单，但在 Java 中被证明比我预期的更棘手。主要概念是 lambda、将函数作为参数传递以及并行集合。我的问题是:如何改进Java代码，有几件事我想做:

1. 首先返回测量函数中函数的结果，我尝试使用泛型，但没有立即成功(我猜我做错了什么)
2. 从序列中创建列表的更好方法，我不期望像(0到10)那么简单，但也许......
3. 更好的排列实现，一些java库。 scala 中的算法执行速度快了 10 倍，但我的只是堆栈溢出的一份副本，因为我找不到 native 或库。
4. 为什么即使是 void 表达式，我也需要在 lambda 表达式中返回 null？在 scala 中，我知道一切都会返回一些东西，即使它什么都没有

这不是两种语言之间的比较，实际上这可能是，这是一个学习代码，从一个学习 Java 编码的人的角度来看，然后开始在 Scala 中编码，以便有趣和功能性地学习它们到 Java 8 看看有什么新变化。这样一来，我就不是 Scala 和函数式编程方面的专家了。

让我们看代码

Scala 版本:

object ParalelTest {
  def measure[T] (func: => T):T ={
    val start = System.nanoTime()
    val result = func
    val elapsed = System.nanoTime() - start
    println("A execução do metodo demorou %s ns".format(elapsed))
    result
  }
  var sum:Int = _
  def heavyComputation ="abcdefghij".permutations.foreach(i=> sum+=1)

  def main(args: Array[String]) {
    measure(heavyComputation)
    println(s"Soma das permutacoes: ${sum}")
    measure((0 to 10).foreach(i => heavyComputation))
    measure((0 to 10).par.foreach(i => heavyComputation))
    println(s"Soma das permutacoes: ${sum}")
  }


}

Java 版本(当时最好的版本)

public class ParallelTest implements Runnable {
    int sum =0;
    private void measure(Callable callable) {
        long start = System.nanoTime();

        try {
            callable.call();
        } catch (Exception e) {
            e.printStackTrace();
        }
        long elapsed = System.nanoTime() -  start;
        System.out.println(String.format("A execução demorou  %s ns",elapsed));

    }

    private Integer heavyComputation(){
       sum = 0;
       permutation("abcdefghij").stream().forEach(i -> sum++);
       return sum;
    }
    public Collection<String> permutation(String str) {
        List<String> permutations = new ArrayList<>();
        permutation("", str, permutations);
        return permutations;
    }

    private void permutation(String prefix, String str, Collection<String> permutations) {

        int n = str.length();
        if (n == 0) permutations.add(prefix);
        else {
            for (int i = 0; i < n; i++)
                permutation(prefix + str.charAt(i), str.substring(0, i) + str.substring(i+1, n), permutations);
        }
    }
    @Override
    public void run() {
        System.out.println("Running one heavycomputations");
        measure(this::heavyComputation);
        // First we need to fill the list (there is no '0 to 10')
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 9; i++) {
            list.add(i);
        }
        // Sequencial
        System.out.println("Running 10 sequencial heavy computations");
        measure(()-> {
            list.stream().forEach(i -> this.heavyComputation());
            return null;
        });

        // Parallel
        System.out.println("Running 10 in parallel");
        measure(() -> {
            list.parallelStream().forEach(i -> this.heavyComputation());
            return null;
        });
    }

}

Answer 1

这是卢西亚诺答案的一个轻微变体。关于您的4个问题:

• 返回类型:使用泛型
• int range:使用 IntStream.range
• 排列算法:很容易自己实现，参见Heap's algorithm
• 返回类型:使用重载方法

这是完整的代码(除了排列的实现):

public class ParallelTest {
    private static <T> T measure(Supplier<T> func) {
        long start = System.nanoTime();
        T result = func.get();
        long elapsed = System.nanoTime() - start;
        System.out.printf("Execution time %dns\n", elapsed);
        return result;
    }
    private static void measure(Runnable runnable) {
        measure(() -> { runnable.run(); return ""; });
    }
    private static int sum = 0; // Warning: data race
    private static void heavyComputation() {
        Permutations.of("abcdefghij").forEach(i -> ++sum);
    }
    public static void main(String... args) {
        measure(ParallelTest::heavyComputation);
        System.out.printf("Sum: %s\n", sum);
        measure(() -> IntStream.range(0, 10).forEach(i -> heavyComputation()));
        measure(() -> IntStream.range(0, 10).parallel().forEach(i -> heavyComputation()));
        System.out.printf("Sum: %s\n", sum);
    }
}

但是，在比较语言时要小心。我建议使用基于您日常工作的示例。上面的例子是自己编的，有一些问题。例如:

• 变量 sum 上存在不良数据争用
• 流旨在对大流进行少量计算，而不是对小流进行大量计算
• 性能主要由排列的实现决定，这是一个很少使用的函数