在 Java 8 中迭代 Java 数组

Question

这是一个简单的算法问题，

给定一个n>1的整数数组，nums，返回一个数组输出 使得 output[i] 等于所有元素的乘积 除 nums[i] 之外的 nums。在 O(n) 中解决它而不用除法。为了 例如，给定 [1,2,3,4]，返回 [24,12,8,6]。

这是我的解决方案，

public static int[] productExceptSelf(int[] nums) {

    int[] result = new int[nums.length];

    int leftProduct = 1;
    int rightProduct = 1;

    for(int i = 0; i < result.length; i++){
        result[i] = leftProduct;
        leftProduct *= nums[i];
    }

    for(int i=nums.length -1; i >= 0; i --){
        result[i] *= rightProduct;
        rightProduct *= nums[i];
    }
    return result;
}

public static void main(String[] args) {
    int[] output = productExceptSelf(new int[]{1, 2, 3, 4});
    Arrays.stream(output).forEach(System.out::println);
}

这很好用。我想要学习的是如何在 Java 8 中重写这段代码。就像 Java 8 中循环的不同选项一样。

Answer 1

你可以用几行不同的代码来做：

public static int[] productExceptSelf(int[] nums) {
    int all = Arrays.stream(nums).reduce(1, (x, y) -> x * y);
    return IntStream.range(0, nums.length).map(x -> all / nums[x]).toArray();
}

Answer 2

几个 cmets 和答案都提到流 API 不适合解决这类问题。我同意;使用数组要容易得多。这是我的做法：

static int[] productExceptSelf(int[] nums) {
    int len = nums.length;

    int[] lefts = new int[len];
    Arrays.setAll(lefts, i -> i == 0 ? 1 : lefts[i-1] * nums[i-1]);

    int[] rights = new int[len]; // reversed
    Arrays.setAll(rights, i -> i == 0 ? 1 : rights[i-1] * nums[len-i]);

    int[] result = new int[len];
    Arrays.setAll(result, i -> lefts[i] * rights[len-i-1]);

    return result;
}

public static void main(String[] args) {
    int[] nums = { 1, 2, 3, 4 };
    System.out.println(Arrays.toString(productExceptSelf(nums)));
}

这在概念上与迭代方法非常相似，但它将完整的中间结果存储在临时数组中，以便利用 Arrays.setAll 操作。这会占用更多空间，但执行的乘法次数相同。

我注意到Arrays.setAll 的规范不保证从左到右的操作，但这种方法需要它。事实上，setAll 基本上是IntStream.range(0, length) 的包装，因此如果担心对setAll 的依赖，您可以自己轻松编写此实用程序。

请注意，这基本上是一个“前缀”或“扫描”操作，如Flown's answer 所示。 (+1) 不幸的是，Arrays.parallelPrefix 的局限性，例如无法指定初始元素，以及无法从右到左扫描（以及缺乏反转原始数组的内置方法）使得这种方法虽然不错，但很不方便。

Answer 3

这可以满足您的要求，但我觉得它需要更多优雅:-D

public static void main(String[] args) {
    List<Integer> output = productExceptSelf(new int[]{1, 2, 3, 4});
    output.forEach(System.out::println);
}

public static List<Integer> productExceptSelf(int[] nums) {
    List<Integer> list = Arrays.stream(nums).boxed().collect(Collectors.toList());
    List<Integer> results = new ArrayList<>();
    list.forEach(value -> {
        int x = 1;
        for (Integer i : list) {
            if (value.equals(i)) continue;
            x *= i;
        }
        results.add(x);
    });
    return results;
}

Answer 4

正如 cmets 中已经说过的：Streams 不太适合这种任务，但是 JDK 中还有其他方法，例如 Arrays::parallelPrefix。

我采纳了你的想法并将其转化为：

private static int[] productExceptSelf(int[] arr) {
  IntBinaryOperator product = (a, b) -> a * b;

  int[] leftPrefix = IntStream.concat(IntStream.of(1), IntStream.of(arr)).toArray();
  Arrays.parallelPrefix(leftPrefix, product);

  int[] reversedRightPrefix = reversed(IntStream.concat(IntStream.of(arr), IntStream.of(1))
                                             .toArray());
  Arrays.parallelPrefix(reversedRightPrefix, product);
  //Could be calculated on-the-fly: reversedRightPrefix[reversedRightPrefix - i - 2]
  int[] rightPrefix = reversed(reversedRightPrefix);

  return IntStream.range(0, arr.length)
                 .map(i -> product.applyAsInt(leftPrefix[i], rightPrefix[i + 1]))
                 .toArray();
}

private static int[] reversed(int[] arr) {
  return IntStream.range(0, arr.length).map(i -> arr[arr.length - 1 - i]).toArray();
}

由于您要求循环替代方案，您可以使用递归（仍然是 Java 8 代码）：

private static int[] productExceptSelf(int[] arr) {
  int[] result = new int[arr.length];
  productExceptSelf(arr, result, 0, 1);
  return result;
}

private static int productExceptSelf(int[] arr, int[] result, int i, int leftPrefix) {
  if (arr.length <= i) {
    return 1;
  }
  int rightPrefix = productExceptSelf(arr, result, i + 1, leftPrefix * arr[i]);
  result[i] = leftPrefix * rightPrefix;
  return rightPrefix * arr[i];
}