标签: java-8

我想开始在Eclipse中使用Java 8,但我不知道如何安装它 - 我找不到任何关于它的教程.我正在使用Eclipse Kepler并为IDE添加了JDK 8的JRE,但由于JRE版本的合规性问题,它不会让我继续创建项目.如何在Eclipse Kepler IDE中使用Java 8？

我一直在Java 8中使用CompletionStage/CompletableFuture来进行异步处理,这非常有效.但是,有时我想要一个阶段来执行迭代器/项目流的异步处理,似乎没有办法做到这一点.

具体来说,Stream.forEach()具有语句,在调用之后所有项都已处理完毕.我想要同样的东西,但改为使用CompletionStage,例如:

CompletionStage<Void> done = stream.forEach(...);
done.thenRun(...);

如果Stream由异步流式传输结果支持,那么比等待它在上面的代码本身中完成要好得多.

是否有可能以某种方式使用当前的Java 8 API构建它？解决方法？

假设我有一些异步计算,例如:

CompletableFuture
        .supplyAsync(() -> createFoo())
        .thenAccept(foo -> doStuffWithFoo(foo));

如果异步供应商根据某些指定的超时超时,是否有一种很好的方法为foo提供默认值？理想情况下,此类功能也会尝试取消运行缓慢的供应商.例如,是否存在类似于以下假设代码的标准库功能:

CompletableFuture
        .supplyAsync(() -> createFoo())
        .acceptEither(
                CompletableFuture.completedAfter(50, TimeUnit.MILLISECONDS, DEFAULT_FOO),
                foo -> doStuffWithFoo(foo));

或者甚至更好:

CompletableFuture
        .supplyAsync(() -> createFoo())
        .withDefault(DEFAULT_FOO, 50, TimeUnit.MILLISECONDS)
        .thenAccept(foo -> doStuffWithFoo(foo));

我知道get(timeout, unit),但我想知道是否有一种更好的标准方式,以异步和反应方式应用超时,如上面的代码所示.

编辑:这是一个受Java 8启发的解决方案:在lambda表达式中强制检查异常处理.为什么强制,不是可选的？,但不幸的是它阻止了一个线程.如果我们依赖createFoo()来异步检查超时并抛出自己的超时异常,它可以在不阻塞线程的情况下工作,但会给供应商的创建者带来更多负担,并且仍然会产生创建异常的成本(可以没有"快速投掷"而昂贵

static <T> Supplier<T> wrapped(Callable<T> callable) {
    return () -> {
        try {
            return callable.call();
        } catch (RuntimeException e1) {
            throw e1;
        } catch (Throwable e2) {
            throw new RuntimeException(e2);
        }
    };
}
CompletableFuture
        .supplyAsync(wrapped(() -> CompletableFuture.supplyAsync(() -> createFoo()).get(50, …

需要一些帮助思考来自我的同伴StackOverflow名人的lambda.

选择列表列表以在图表中深入收集一些孩子的标准情况.什么样的方法可以Lambdas帮助这个样板？

public List<ContextInfo> list() {
    final List<ContextInfo> list = new ArrayList<ContextInfo>();
    final StandardServer server = getServer();

    for (final Service service : server.findServices()) {
        if (service.getContainer() instanceof Engine) {
            final Engine engine = (Engine) service.getContainer();
            for (final Container possibleHost : engine.findChildren()) {
                if (possibleHost instanceof Host) {
                    final Host host = (Host) possibleHost;
                    for (final Container possibleContext : host.findChildren()) {
                        if (possibleContext instanceof Context) {
                            final Context context = (Context) possibleContext;
                            // copy to another object -- not …

假设你有一个List数字.在该值List可以是类型的Integer,Double等等.当你声明这样的List有可能使用一个通配符(声明它?)或不用一个通配符.

final List<Number> numberList = Arrays.asList(1, 2, 3D);
final List<? extends Number> wildcardList = Arrays.asList(1, 2, 3D);

所以,现在我想stream在List和collect它所有的Map使用Collectors.toMap(显然下面的代码只是为了说明问题的例子).让我们开始流式传输numberList:

final List<Number> numberList = Arrays.asList(1, 2, 3D, 4D);

numberList.stream().collect(Collectors.toMap(
        // Here I can invoke "number.intValue()" - the object ("number") is treated as a Number
        number -> Integer.valueOf(number.intValue()),
        number -> number));

但是,我不能对以下内容做同样的操作wildcardList:

final List<? extends Number> wildCardList …

假设我有一串字符串.

final Stream<String> stream = ...;

我想在修剪后过滤掉每个空字符串.

stream
    .filter(Objects::nonNull)
    .map(String::trim)
    .filter(v -> !v.isEmpty());

有没有办法应用Predicate#negate()替换v -> !v.isEmpty()部分？

.filter(((Predicate) String::isEmpty).negate()) // not compile

我创建了简单的演示:

public static void main(String[] args) {
        List<String> list2 = Arrays.asList("adf", "bcd", "abc", "hgr", "jyt", "edr", "biu");

String collect = list2.stream().collect(String::new, (res, elem) -> {
              res=res.concat(" ").concat(elem);
//            System.out.printf("res=%s, elem=%s\n", res.isEmpty(), elem);

        }, (res1, res2) -> {
            System.out.printf("res1=%s, res2=%s\n", res1, res2);            
        });
        System.out.println("collect=" + collect);
}

问题是BiConsumer combiner部分collect根本没有运行.

如果我使用parallelStream()两个参数res1并且res2等于供应商,它就会运行String::new.

如何combiner在collect方法中工作？

我正在尝试将a转换Map<String, List<String>>为a Map<String, String>,其中每个键的值是通过连接List上一个映射中的所有值而构建的联合字符串,例如:

A -> ["foo", "bar", "baz"]
B -> ["one", "two", "three"]

应转换为

A -> "foo|bar|baz"
B -> "one|two|three"

使用Java 8 Streams API执行此操作的惯用方法是什么？

使用Java 8 StreamAPI,我想注册一个"完成钩子",类似于:

Stream<String> stream = Stream.of("a", "b", "c");

// additional filters / mappings that I don't control
stream.onComplete((Completion c) -> {
    // This is what I'd like to do:
    closeResources();

    // This might also be useful:
    Optional<Throwable> exception = c.exception();
    exception.ifPresent(e -> throw new ExceptionWrapper(e));
});

我为什么要那么做的原因是因为我想包装在一个资源Stream的API客户端,消费,我想的是Stream,一旦它被消耗自动清理资源.如果可能,那么客户可以致电:

Collected collectedInOneGo =
Utility.something()
       .niceLookingSQLDSL()
       .moreDSLFeatures()
       .stream()
       .filter(a -> true)
       .map(c -> c)
       .collect(collector);

而不是目前所需要的:

try (Stream<X> meh = Utility.something()
                            .niceLookingSQLDSL()
                            .moreDSLFeatures()
                            .stream()) {

    Collected collectedWithUglySyntacticDissonance = …

我刚刚被提示更新Java.它告诉我:

有人知道那个"助手"工具是做什么的吗？如果它是新的我可能不需要它.有没有办法选择退出？或者至少在安装之前知道它是什么？

请注意,我已经在"系统偏好设置"下的"Java控制面板"中选中了禁止赞助商优惠的选项.

另请注意,如果我未输入管理员密码,则不会安装更新.除了更新之外,它不是提供的,我可以接受或拒绝.

如果这是一个不好的问题或错误的地方,请评论.

这是一个后续行动.

我再次收到消息,并搜索了有关它的更多信息.我了解到更新过程已经包含在应用程序中.应用程序包装实际包,并提出其他软件.如果您选择退出,我猜它只是安装了Java更新.

"新助手工具"可能就是这个安装包装器,或者如果您不选择退出,可能还会提供其他软件.

如果您更喜欢安装干净的软件包,可以从安装程序中提取它.下载更新后,单击取消.然后转到~/Library/Application Support/Java(~/Library隐藏,所以使用Go> Go to folder ...).您可以看到所有过去的Java更新下载.选择最新版本.在文件夹中,您会看到一个应用程序和一个dmg.右键单击应用程序并选择Show Package Contents.在应用程序里面去Contents/Resources.你找到一个包裹JavaAppletPlugin.pkg.那是实际的包裹.双击它进行安装.它仍会询问您的姓名和密码,但这次是由OSX/macOS询问并用于安装该软件包而不是其他任何内容.

最新更新:今天更新失败.发生这种情况时,立即删除下载.在这种情况下,上述方法不起作用.

这开始看起来像博客.失败的下载是由于我的杀毒软件.当我禁用它时,它再次起作用.无论如何,我现在相信这个信息是无害的.操作系统X询问我是否同意运行Java安装程序.它不会尝试安装任何其他东西.我跑了.