标签: java-8

并行流可能会产生与Java 8中的串行流不同的结果吗？根据我的信息,并行流与串行流相同,除了分成多个子流.这是一个速度问题.完成对元素的所有操作,并在最后组合子流的结果.最后,在我看来,对于并行和串行流,操作的结果应该是相同的.所以我的问题是,这段代码可能会给我一个不同的结果吗？如果有可能,为什么会发生？

int[] i = {1, 2, 5, 10, 9, 7, 25, 24, 26, 34, 21, 23, 23, 25, 27, 852, 654, 25, 58};
Double serial = Arrays.stream(i).filter(si -> {
    return si > 5;
}).mapToDouble(Double::new).map(NewClass::add).reduce(Math::atan2).getAsDouble();

Double parallel = Arrays.stream(i).filter(si -> {
    return si > 5;
}).parallel().mapToDouble(Double::new).map(NewClass::add).reduce(Math::atan2).getAsDouble();

System.out.println("serial: " + serial);
System.out.println("parallel: " + parallel);

public static double add(double i) {
    return i + 0.005;
}

结果是:

serial: 3.6971567726175894E-23

parallel: 0.779264049587662

我在使用GC日志的几台服务器上遇到问题.它充满了这个:

^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@
^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@
^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@

注意到这发生在给JVM提供大量内存的服务器上:-Xms32G -Xmx48G.这可能是一个红鲱鱼,但想提到它.

由于这些是低延迟/高吞吐量的应用程序,分析日志至关重要.但相反,它充满了上面的那些字符.

我们使用的是Java 8:

java version "1.8.0_40"
Java(TM) SE Runtime Environment (build 1.8.0_40-b26)
Java HotSpot(TM) 64-Bit Server VM (build 25.40-b25, mixed mode)

我们用它来创建日志:

-verbose:gc
-Xloggc:/path/to/gc.log
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps

以前有人见过这个问题吗？可能导致什么？

我的原始代码是这样的:

private static void onClicked(MouseEvent event) {
    // code to execute
}

// somewhere else in the program:
setOnMouseClicked(event -> SomeClass.onClicked(event));

但IntelliJ说"可以用方法参考替换",我不太清楚该怎么做.我以为我会这样做:

setOnMouseClicked(event -> SomeClass::onClicked);

但后来告诉我"虚空不是一个功能界面",但我不想返回任何东西.我只想要执行处理程序.我怎样才能解决这个问题？

谢谢!

通常,并不十分清楚并行流如何将输入分成块以及块连接的顺序.有没有办法可视化任何流源的整个过程,以更好地了解正在发生的事情？假设我创建了一个这样的流:

Stream<Integer> stream = IntStream.range(0, 100).boxed().parallel();

我想看到一些树状的结构:

             [0..99]
         _____/   \_____
        |               |
     [0..49]         [50..99]
    __/   \__        __/  \__
   |         |      |        |
[0..24]  [25..49] [50..74] [75..99]

这意味着整个输入范围[0..99]被拆分为范围,[0..49]而[50..99]范围又进一步分裂.当然这样的图应该反映Stream API的实际工作,所以如果我用这样的流执行一些实际操作,则应该以相同的方式执行拆分.

我正在用一个定义带注释的接收器类型的方法来查看一个相当简单的类:

class Foo<T> { 
  void foo(Foo<@Bar T> this) {}
}

我现在想访问接收器类型参数的类型注释,@Bar但Java反射API在访问接收器时返回带注释的原始类型:

assert Foo.class.getDeclaredMethod("foo")
                .getAnnotatedReceiverType() 
  instanceof AnnotatedParameterizedType;

断言失败,因为返回的带注释的类型作为原始类型返回Foo.这是故意的吗？@Bar当访问AnnotatedType返回的实现的私有属性时,我仍然可以找到注释.

我正在运行最新版本的Java 8.

我有一个对象列表:

List<SomeType> myList;

我想获得此列表中可用的子类型列表:

List<SomeChildType> myChildList = myList.stream().filter(e -> e instanceof SomeChildType).collect(??????)

我不知道如何收集以获得正确的列表类型.

这段代码在Eclipse中编译,但不在javac中编译:

import java.util.function.Consumer;

public class Test {
    public static final void m1(Consumer<?> c) {
        m2(c);
    }
    private static final <T> void m2(Consumer<? super T> c) {
    }
}

javac输出:

C:\Users\lukas\workspace>javac -version
javac 1.8.0_92

C:\Users\lukas\workspace>javac Test.java
Test.java:5: error: method m2 in class Test cannot be applied to given types;
        m2(c);
        ^
  required: Consumer<? super T>
  found: Consumer<CAP#1>
  reason: cannot infer type-variable(s) T
    (argument mismatch; Consumer<CAP#1> cannot be converted to Consumer<? super T>)
  where T is a type-variable:
    T extends Object declared …

我目前正在替换所有标准POJO,以便将Lombok用于所有样板代码.我发现自己保留了列表的getter,因为如果列表尚未初始化,我想返回一个空列表.也就是说,我不希望getter返回null.如果有一些我不知道的lombok魔法可以帮助我避免这样做吗？

生成代码的示例

private List<Object> list;
public Object getList(){ return list; }

我想要的是:

private List<Object> list;
public Object getList(){
    if (list == null) {
        return new ArrayList();
    }
    return list;
}

对于Collectors.groupingBy()那个返回Map<K,List<T>>,它暗示List<T>是为了评估流？

我没有看到列表排序的明确描述,而并发版本明确表示没有排序.如果它没有以某种方式订购,我会期望它是一个收藏品,我不会看到除了收到订单之外的其他订单.

我希望保证每个列表中的最后一个值是该组收到的最后一个值.

我需要在我正在处理的异步框架中提交任务,但我需要捕获异常,并在"中止"之前多次重试相同的任务.

我正在使用的代码是:

int retries = 0;
public CompletableFuture<Result> executeActionAsync() {

    // Execute the action async and get the future
    CompletableFuture<Result> f = executeMycustomActionHere();

    // If the future completes with exception:
    f.exceptionally(ex -> {
        retries++; // Increment the retry count
        if (retries < MAX_RETRIES)
            return executeActionAsync();  // <--- Submit one more time

        // Abort with a null value
        return null;
    });

    // Return the future    
    return f;
}

这当前不能编译,因为lambda的返回类型是错误的:它期望a Result,但executeActionAsync返回a CompletableFuture<Result>.

如何实现这个完全异步重试逻辑？