小编Udo*_*Udo的帖子

在Java8中运行以下流示例:

    System.out.println(Stream
        .of("a", "b", "c", "d", "e", "f")
        .reduce("", (s1, s2) -> s1 + "/" + s2)
    );

收益率:

/a/b/c/d/e/f

这是 - 当然 - 毫不奇怪.由于http://docs.oracle.com/javase/8/docs/api/index.html?overview-summary.html,流顺序执行还是并行执行无关紧要:

除了标识为显式非确定性的操作(例如findAny())之外,流是顺序执行还是并行执行不应更改计算结果.

AFAIK reduce()是确定性的并且(s1, s2) -> s1 + "/" + s2是关联的,因此添加parallel()应该产生相同的结果:

    System.out.println(Stream
            .of("a", "b", "c", "d", "e", "f")
            .parallel()
            .reduce("", (s1, s2) -> s1 + "/" + s2)
    );

但是我机器上的结果是:

/a//b//c//d//e//f

这有什么不对？

BTW:使用(首选).collect(Collectors.joining("/"))而不是为顺序和并行执行reduce(...)产生相同的结果a/b/c/d/e/f.

JVM详细信息:

java.specification.version: 1.8
java.version: 1.8.0_31
java.vm.version: 25.31-b07
java.runtime.version: 1.8.0_31-b13

给出某些类中所有spring数据存储库的列表Bar:

@Autowired
private List<Repository> repositories;

如何Foo在上面的列表中找到现有域类的存储库？

假设存在以下内容:

@Entity
public class Foo {
  ...
}

和

public interface FooRepository extends JpaRepository<Foo, String> {}

给定一些类SomeBaseClass,这两个方法声明是否等效？

public <T extends SomeBaseClass> void myMethod(Class<T> clz)

和

public void myMethod(Class<? extends SomeBaseClass> clz)

给出以下XML

<mappings>
  <map>
     <source srcAttr="oof">foo</source>
     <target trgAttr="rab">bar</target>
  </map>
  <map>
    ...

是否有可能与JAXB解组的<map>元素为单个类Map 含有值和属性<source>和<target>？

@XmlRootElement
class Map {

   @XmlElement
   String source;

   @???
   String srcAttr;

   @XmlElement
   String target;

   @???
   String trgAttr;
}

我不想为Source和target创建额外的类.

我想比较两个Java8流终端操作reduce()以及collect()它们的并行性能.

我们来看看下面的Java8并行流示例:

import java.math.BigInteger;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;

import static java.math.BigInteger.ONE;

public class StartMe {

    static Function<Long, BigInteger> fac;

    static {
        fac = x -> x==0? ONE : BigInteger.valueOf(x).multiply(fac.apply(x - 1));
    }

    static long N = 2000;

    static Supplier<BigInteger[]> one() {
        BigInteger[] result = new BigInteger[1];
        result[0] = ONE;
        return () -> result;
    }

    static BiConsumer<BigInteger[], ? super BigInteger> accumulator() {
        return (BigInteger[] ba, BigInteger b) -> {
            synchronized (fac) {
                ba[0] …

鉴于某些课程SomeBaseClass.这两个方法声明是否相同？

public <T extends SomeBaseClass> void myMethod(T param) 

和

public void myMethod(<? extends SomeBaseClass> param)