标签: java-8

因此,我正在将Android Studio项目迁移到Java 8,Android API级别24和Jack工具链,以检查新功能,尤其是lambdas和CompletableFuture.

不幸的是,CompletableFuture似乎仅在API级别24上可用(我的该项目的最低API级别为16).

你知道有关带到CompletableFutureAndroid支持库的任何计划吗？它似乎是Promises模式的一个很好的解决方案.

我试图将List所有书中的所有书Collection都放在另一本书中.我的问题是我需要根据书籍ID进行比较,所以我不能只测试第一个书中是否包含第一本书,我必须确定第二个集合中的任何书籍是否与第一本书.

我有以下代码来比较两个书籍集合并过滤第一个集合:

List<Book> parentBooks = listOfBooks1.stream().filter(book->
  !listOfBooks2.contains(book)).collect(Collectors.toList());

Run Code Online (Sandbox Code Playgroud)

代码无法正常工作,因为我正在比较对象本身.我需要比较基于bookId的对象而不是整个书对象.我应该如何更改代码,以便它可以根据bookId(book.getId())进行比较？

我是lambda和Java8的新手.我正面临以下错误.

在封闭范围内定义的局部变量日志必须是最终的或有效的最终

public JavaRDD<String> modify(JavaRDD<String> filteredRdd) {

    filteredRdd.map(log -> {

        placeHolder.forEach(text -> {

            //error comes here
            log = log.replace(text, ",");

        });

        return log;

    });

    return null;
}

我有这种奇怪的类型,CompletableFuture<CompletableFuture<byte[]>>但我想要CompletableFuture<byte[]>.这可能吗？

public Future<byte[]> convert(byte[] htmlBytes) {
    PhantomPdfMessage htmlMessage = new PhantomPdfMessage();
    htmlMessage.setId(UUID.randomUUID());
    htmlMessage.setTimestamp(new Date());
    htmlMessage.setEncodedContent(Base64.getEncoder().encodeToString(htmlBytes));

    CompletableFuture<CompletableFuture<byte[]>> thenApply = CompletableFuture.supplyAsync(this::getPhantom, threadPool).thenApply(
        worker -> worker.convert(htmlMessage).thenApply(
            pdfMessage -> Base64.getDecoder().decode(pdfMessage.getEncodedContent())
        )
    );

}

我们的数据存储区中的记录具有有效和到期时间.此信息使用字符串表示形式存储Instant.

有些记录永远不会过期.但由于到期日的值是强制性的,我们决定存储字符串表示Instant.MAX.

到现在为止还挺好.我们有搜索用例来返回在输入时间范围内有效的所有记录[s,e].我们查询数据存储区并返回[Si, Ei]满足条件的所有此类记录Si < s && e < Ei请注意,此处将比较字符串表示形式.

现在的问题是,+它被预先添加到字符串表示中Instant.MAX.这是失败的条件e < Ei,因为ASCII('+') < ASCII(digit).

我已经写了一段代码知道之后second,+开始得到前提:

Long e = Instant.now().getEpochSecond()*1000;
for (int i = 0; i < 5; i++) {
    System.out.println(e + "->" + Instant.ofEpochMilli(e));
    e *= 10;
}

打印:

1471925168000->2016-08-23T04:06:08Z
14719251680000->2436-06-07T17:01:20Z
147192516800000->6634-05-07T02:13:20Z
1471925168000000->+48613-06-14T22:13:20Z
14719251680000000->+468404-07-08T06:13:20Z

我可以选择截断+之前持久化的数据存储区.我更感兴趣的是为什么会这样,我们怎么能明确地避免它呢？

我有几个类,如下

class Pojo {
    List<Item> items;
}

class Item {
    T key1;
    List<SubItem> subItems;
}

class SubItem {
    V key2;
    Object otherAttribute1;
}

我想根据key1每个聚合聚合项目,子项目应按key2以下方式聚合:

Map<T, Map<V, List<Subitem>>

Java 8 Collectors.groupingBy嵌套有什么可能吗？

我正在尝试一些东西并且中途停留

pojo.getItems()
    .stream()
    .collect(
        Collectors.groupingBy(Item::getKey1, /* How to group by here SubItem::getKey2*/)
    );

注意:这与级联不同groupingBy,后者根据此处讨论的同一对象中的字段进行多级聚合

这段代码有什么区别？

Supplier<LocalDate> s1 = LocalDate::now;
LocalDate s2 = LocalDate.now();

System.out.println(s1.get()); //2016-10-25
System.out.println(s2); //2016-10-25

我开始学习Java 8中的功能接口,而不了解供应商的好处.究竟何时以及如何使用它们.供应商是否提高了绩效或者提取抽象水平的好处？

谢谢你的回答!这不是重复的问题,因为我使用搜索并没有找到我需要的东西.

更新1: 你的意思是这个？

    Supplier<Long> s1 = System::currentTimeMillis;
    Long s2 = System.currentTimeMillis();

    System.out.println(s1.get()); //1477411877817
    System.out.println(s2); //1477411877817
    try {
        Thread.sleep(3000l);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(s1.get()); //1477411880817 - different
    System.out.println(s2); //1477411877817

Java 8并行流如何在使用子句中的抛出异常上运行,例如在forEach处理中？例如,以下代码:

final AtomicBoolean throwException = new AtomicBoolean(true);
IntStream.range(0, 1000)
    .parallel()
    .forEach(i -> {
        // Throw only on one of the threads.
        if (throwException.compareAndSet(true, false)) {
            throw new RuntimeException("One of the tasks threw an exception. Index: " + i);
        });

它会立即停止处理元素吗？是否等待已经启动的元素完成？是否等待所有流完成？抛出异常后是否开始处理流元素？

什么时候回来？异常后立即？毕竟/部分元素是由消费者处理的？

在并行流引发异常后,是否继续处理元素？(发现这种情况发生的情况).

这里有一般规则吗？

编辑(15-11-2016)

试图确定并行流是否提前返回,我发现它不是确定的:

@Test
public void testParallelStreamWithException() {
    AtomicInteger overallCount = new AtomicInteger(0);
    AtomicInteger afterExceptionCount = new AtomicInteger(0);
    AtomicBoolean throwException = new AtomicBoolean(true);

    try {
        IntStream.range(0, 1000)
            .parallel()
            .forEach(i -> {
                overallCount.incrementAndGet();
                afterExceptionCount.incrementAndGet();
                try …

我有代码实现任意键的"锁定处理程序".给定a key,它确保一次只有一个线程可以process(或等于)密钥(这意味着调用该externalSystem.process(key)呼叫).

到目前为止,我有这样的代码:

public class MyHandler {
    private final SomeWorkExecutor someWorkExecutor;
    private final ConcurrentHashMap<Key, Lock> lockMap = new ConcurrentHashMap<>();

    public void handle(Key key) {
        // This can lead to OOM as it creates locks without removing them
        Lock keyLock = lockMap.computeIfAbsent( 
            key, (k) -> new ReentrantLock()
        );
        keyLock.lock();
        try {
            someWorkExecutor.process(key);
        } finally {
            keyLock.unlock();
        }
    }
}

我明白这段代码可以导致OutOfMemoryError因为没有一张清晰的地图.

我想如何制作积累有限数量元素的地图.当超过限制时,我们应该用new替换最旧的访问元素(此代码应与作为监视器的最旧元素同步).但是我不知道怎么回调会说我超出限制.

请分享你的想法.

PS

我重读了这个任务,现在我发现我有限制,handle不能调用超过8个线程的方法.我不知道它对我有什么帮助,但我刚提到它.

PS2

通过@Boris,Spider被认为是一个简单明了的解决方案:

} finally {
      lockMap.remove(key);
      keyLock.unlock();
} …

我目前正在解决使用Java 8中的Lambdas使用按位运算的转换for循环的问题.

给定一组复杂的条目,循环需要遍历所有条目并在它们上调用给定的方法(方法返回布尔值).然后,返回结果.

换句话说,我需要在所有条目上调用该方法并存储结果.这背后的原因是每个条目独立地执行复杂的操作并且必须执行.最终结果是结果的组合.

代码段:

boolean areAllSuccessful = true;
for (SomeEntry entry : entries) {
     areAllSuccessful = areAllSuccessful & entry.doComplexAction(); // keep calling the method on other entries regardless of the result.
}

return areAllSuccessful;

问题是Java 8中的Lambda函数通常执行短路操作(一旦检测到错误条目,"循环"中断并返回错误结果).

到目前为止,我最好的解决方案是使用map/filter/count组合:

return entries
       .stream()
       .map(entry -> entry.doComplexAction())
       .filter(result -> result == false)
       .count() > 0

有更聪明/更清洁的方式吗？

谢谢!