标签: java-8

我问这个问题是因为我正在创建大量的执行程序服务,虽然我可能已经在需要调查的地方发生了内存泄漏,但我认为最近对以下代码的更改实际上使其恶化,因此我试图确认到底是怎么回事:

@FunctionalInterface
public interface BaseConsumer extends Consumer<Path> {
    @Override
    default void accept(final Path path) {
        String name = path.getFileName().toString();
        ExecutorService service = Executors.newSingleThreadExecutor(runnable -> {
            Thread thread = new Thread(runnable, "documentId=" + name);
            thread.setDaemon(true);
            return thread;
        });
        Future<?> future = service.submit(() -> {
            baseAccept(path);
            return null;
        });
        try {
            future.get();
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException ex) {
            throw new RuntimeException(ex);
        }
    }

    void baseAccept(final Path path) throws Exception;
}

然后Consumer<Path>在另一个具有(通常)N = 2个线程的线程池上调用它,我不确定这是否相关.

问题是:一旦完成,是否ExecutorService …

以下类有一个名为的内部类Entry.此代码不会在Java 8中编译,因为编译器假定Entry双花括号初始值设定项中的引用是类型Map.Entry而不是Scope.Entry.这段代码在JDK的先前版本(至少6和7)中编译,但在JDK 8中被破坏.我的问题是"为什么？" Map.Entry未在此类中导入,因此编译器没有理由假设该值是类型Map.Entry.是否有一些隐含的范围被引入或匿名类的东西？

错误:

scope/Scope.java:23: error: incompatible types: scope.Scope.Entry cannot be converted to java.util.Map.Entry for (final Entry entry : entries) {
scope/Scope.java:22: error: cannot find symbol put(entry.getName(), entry);

示例代码:

package scope;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

public class Scope {

    public static class Entry<T> {
        public String getName() {
            return "Scope";
        }
    }

    public static void main(String[] args) {
        final Set<Entry> entries = new HashSet<>();

        new HashMap<String, …

以下代码片段是获取目录列表的方法的一部分,在每个文件上调用extract方法并将生成的药物对象序列化为xml.

try(Stream<Path> paths = Files.list(infoDir)) {
    paths
        .parallel()
        .map(this::extract)
        .forEachOrdered(drug -> {
            try {
                marshaller.write(drug);
            } catch (JAXBException ex) {
                ex.printStackTrace();
            }
        });
}

这是完全相同的完全相同的代码,但使用普通.list()调用来获取目录列表并调用.parallelStream()结果列表.

Arrays.asList(infoDir.toFile().list())
    .parallelStream()
    .map(f -> infoDir.resolve(f))
    .map(this::extract)
    .forEachOrdered(drug -> {
        try {
            marshaller.write(drug);
        } catch (JAXBException ex) {
            ex.printStackTrace();
    }
});

我的机器是四核MacBook Pro,Java v 1.8.0_60(内置1.8.0_60-b27).

我正在处理~7000个文件.平均3次运行:

第一版:有.parallel():20秒.没有.parallel():41秒

第二版:带.parallelStream():12秒.用.stream():41秒.

并行模式下的那8秒似乎是一个巨大的差异,因为extract从流中读取并完成所有繁重工作的方法和write执行最终写入的调用都没有改变.

我有Java 8 SDK和运行时,以及只使用Java 7功能的项目.我想知道我是否可以设置intellij来构建一个Java-7级jar,这绝对可以从命令行获得？

到目前为止,我尝试将项目语言级别设置为7作为实验,但这显然是不够的,而不是我真正需要的.

我也在SO上看到了这个问题:" 当我将Java7编译器配置为使用Java6时,使用java7编译器编译Intellij IDEA ",但我的项目SDK已经设置为最新的Java版本,我只需要一个Java-7-兼容的工件/ jar编译.

编辑:我在本地系统上只有Java 6和Java 8 JRE/SDK,因为遗憾的是Java 7在我的系统上存在问题并且不兼容.

是否有一种理智的方式从列表中获取有序流(具体来说,数组列表,但它应该无关紧要)流式元素与它们在原始列表中的方式相反？

我正在寻找一种不涉及缓冲数据的解决方案(收集器,另一个列表,数组等,因为它们复制了浪费的容器),或者使用Collections.reverse(因为它修改了列表).

到目前为止,我在这里看到的最干净的方法之一是实现我自己的版本的Spliterator这ORDERED和在列表中反向前进,或实施Iterator反向迭代是,并使用Spliterators.spliteratorUnknownSize(iterator,ORDERED)它.

注意这个问题不同于Java 8流逆序:其他问题询问如何反转流(一般情况下这是不可能的),并且答案提供了以某种方式反转源(我不想这样做),然后传输反向源.逆转源的成本是O(N),如果可能的话我想完全避免它.

反正有没有得到一个java.time(Java 8中新的)兼容时间类ResultSet？

我知道你可以使用ResultSet's getDate或者getTimestamp这些方法返回java.sql.Date/ java.sql.Timestamp对象现在已被弃用,所以使用它们来创建一个ZonedDateTime或类似的似乎是不好的做法.

我想排序seq1升序和seq2降序所以我这样做:

list = list.stream().sorted(comparing(AClass::getSeq1).thenComparing(        
   AClass::getSeq2).reversed()).collect(toList());

但结果出来了,因为seq1和seq2都按降序排序.

我可以这样做以使seq1升序和seq2降序:

sorted(comparing(AClass::getSeq1)
   .reversed().thenComparing(AClass::getSeq2).reversed()

这是真正的正确方法吗？

我是Java 8的新手,我遇到了Consumer java doc,它说:"预计消费者将通过副作用进行操作." 有人可以解释为什么这么说？

我想循环一个庞大的数组并做一组复杂的指令需要很长时间.但是,如果超过30秒,我希望它放弃.

恩.

final long start = System.currentTimeMillis();
myDataStructure.stream()
    .while(() -> System.currentTimeMillis() <= start + 30000)
    .forEach(e ->
    {
      ...
    });

如果满足某个条件,我想避免return在forEach通话中说话.

基本上这是在试图回答另一个问题时出现的.假设这段代码:

AtomicInteger i = new AtomicInteger(0);
AtomicInteger count = new AtomicInteger(0);
IntStream.generate(() -> i.incrementAndGet())
        .parallel()
        .peek(x -> count.incrementAndGet())
        .limit(5)
        .forEach(System.out::println);

System.out.println("count = " + count);

我理解这IntStream#generate是一个无序的无限流的事实,并且要完成它必须有一个短路操作(limit在这种情况下).我也明白,在Supplier达到该限制之前,Stream实现的次数可以自由调用.

在java-8下运行它会count一直打印512(可能并不总是,但在我的机器上是这样).

在对比运行中,这在java-10下很少超过5.所以我的问题是内部发生了什么变化,短路发生得更好(我试图通过拥有源并试图做一些差异来解决这个问题......)