Java中有什么东西接近Scala中的并行集合吗？

使用Java实现并行计算（例如在多核处理器上）的最简单方法是什么。 即与此Scala代码等效的java

val list = aLargeList
list.par.map(_*2)

---

有，但它似乎势不可挡。

使用线程，Java没有内置这种东西。

在一台机器上实现这一点非常容易，但不像Scala那样容易。您发布的库已经是Java5及更高版本的一部分。可能最简单的使用方法是ExecutorService。表示可以在任何处理器上运行的一系列线程。您向it发送任务，这些任务将返回结果

我建议使用ExecutorService.invokeAll（），它将返回一个未来列表。然后你可以检查他们，看看他们的工作是否完成

如果您使用的是Java7，那么您可以使用fork/join框架，这可能会为您节省一些工作。使用所有这些，您可以构建非常类似于Scala并行阵列的东西，因此使用它相当简洁。

别这么快就放弃，快活！）

（更改映射到您的f）基本问题实际上就是：

ParallelLongArray a = ... // you provide
a.replaceWithMapping (new LongOp() { public long op(long a){return a*2L;}};);

差不多就是这个，对吧

val list = aLargeList
list.par.map(_*2)

&如果你愿意少一点简洁，上面可以是一个相当干净清晰的3行程序（当然，如果你重用函数，那么它与Scala-inline函数完全一样）：

[上面编辑以显示ala OP的Scala变体的简明完整表单]

这里是最详细的形式，我们从头开始演示：

import java.util.Random;
import jsr166y.ForkJoinPool;
import extra166y.Ops.LongGenerator;
import extra166y.Ops.LongOp;
import extra166y.ParallelLongArray;

public class ListParUnaryFunc {
    public static void main(String[] args) {

        int n = Integer.parseInt(args[0]);
        // create a parallel long array 
        // with random long values
        ParallelLongArray a =  ParallelLongArray.create(n-1, new ForkJoinPool());
        a.replaceWithGeneratedValue(generator);

        // use it: apply unaryLongFuncOp in parallel 
        //         to all values in array
        a.replaceWithMapping(unaryLongFuncOp);

        // examine it
        for(Long v : a.asList()){
            System.out.format("%d\n", v);
        }
    }

    static final Random rand = new Random(System.nanoTime());
    static LongGenerator generator = new LongGenerator() {
        @Override final
        public long op() { return rand.nextLong(); }
    };

    static LongOp unaryLongFuncOp = new LongOp() {
        @Override final public long op(long a) { return a * 2L; }
    };
}

最终编辑和注释：

还请注意，下面是一个简单的类（您可以在项目中重用）：

类似的东西将允许您编写更流畅的Java代码（如果简洁性对您很重要的话）：

---

当然，可以推动上述方法，使其更加干净。

在Java8中会有一个等价物：

同意您的公式。的确，Java是一种理智的语言），例如，从snappy的问题到下面的答案，在不到几分钟的时间内阅读jsr源代码（并且是第一次真正阅读这个jsr）。Java的可读性非常好，感谢上帝。JVM也是如此我知道这可能是一个无用的评论，但Java8中有一个新的CollectionsAPI，它做的事情与Scala非常相似：intRange.parallel（）.map（I->I*2）；

import java.util.Random;
import jsr166y.ForkJoinPool;
import extra166y.Ops.LongGenerator;
import extra166y.Ops.LongOp;
import extra166y.ParallelLongArray;

public class ListParUnaryFunc {
    public static void main(String[] args) {

        int n = Integer.parseInt(args[0]);
        // create a parallel long array 
        // with random long values
        ParallelLongArray a =  ParallelLongArray.create(n-1, new ForkJoinPool());
        a.replaceWithGeneratedValue(generator);

        // use it: apply unaryLongFuncOp in parallel 
        //         to all values in array
        a.replaceWithMapping(unaryLongFuncOp);

        // examine it
        for(Long v : a.asList()){
            System.out.format("%d\n", v);
        }
    }

    static final Random rand = new Random(System.nanoTime());
    static LongGenerator generator = new LongGenerator() {
        @Override final
        public long op() { return rand.nextLong(); }
    };

    static LongOp unaryLongFuncOp = new LongOp() {
        @Override final public long op(long a) { return a * 2L; }
    };
}

/**
 * The very basic form w/ TODOs on checks, concurrency issues, init, etc.
 */
final public static class ParArray {
    private ParallelLongArray parr;
    private final long[] arr;
    public ParArray (long[] arr){
        this.arr = arr;
    }
    public final ParArray par() {
        if(parr == null)
            parr = ParallelLongArray.createFromCopy(arr, new ForkJoinPool()) ;
        return this;
    }
    public final ParallelLongArray map(LongOp op) {
        return parr.replaceWithMapping(op);
    }
    public final long[] values() { return parr.getArray(); }
}

long[] arr = ... // you provide
LongOp f = ... // you provide

ParArray list = new ParArray(arr);
list.par().map(f);