标签: java-8

我正在尝试将日期时间管理的各种代码混合清理到只有Java 8 java.time命名空间.现在我有一个小问题,默认DateTimeFormatter为Instant.该DateTimeFormatter.ISO_INSTANT格式只能说明毫秒时,他们不等于零.

时代被渲染为1970-01-01T00:00:00Z而不是1970-01-01T00:00:00.000Z.

我做了一个单元测试来解释这个问题以及我们需要如何将最终日期相互比较.

@Test
public void java8Date() {
    DateTimeFormatter formatter = DateTimeFormatter.ISO_INSTANT;
    String epoch, almostEpoch, afterEpoch;

    { // before epoch
        java.time.Instant instant = java.time.Instant.ofEpochMilli(-1);
        almostEpoch = formatter.format(instant);
        assertEquals("1969-12-31T23:59:59.999Z", almostEpoch );
    }

    { // epoch
        java.time.Instant instant = java.time.Instant.ofEpochMilli(0);
        epoch = formatter.format(instant);
        // This fails, I get 1970-01-01T00:00:00Z instead
        assertEquals("1970-01-01T00:00:00.000Z", epoch );
    }

    { // after epoch
        java.time.Instant instant = java.time.Instant.ofEpochMilli(1);
        afterEpoch = formatter.format(instant);
        assertEquals("1970-01-01T00:00:00.001Z", afterEpoch );
    } …

我一直在寻找RxJava1 https://github.com/ReactiveX/RxJava/releases和RxJava2 https://github.com/ReactiveX/RxJava/wiki/Reactive-Streams的文档,看起来与RxJava 的独特之处在于2有Java Stream.

还有其他不同吗？

我一直在使用1.1.3版本,但我不确定是否值得将其转移到RxJava2,因为我们已经在代码中使用了Java 8流

问候.

我正在努力在spring-boot REST API应用程序中转换一些模型,以使用java 8 java.time.LocalDateTime而不是joda DateTime.我希望API调用返回的时间戳符合ISO_8601格式.动机是与Java 8的时间向前兼容(更多这里).

证明困难的部分是序列化包含LocalDateTimeJSON 的对象.

例如,我有以下实体:

// ... misc imports

import java.time.LocalDateTime;
import java.time.ZoneOffset;

@Data 
@Entity
@Table(name = "users")
public class User {

    @Id @Column
    private String id;

    @Column
    private String name;

    @Column
    private String email;

    @Column
    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss", timezone = "UTC")
    private java.time.LocalDateTime createdAt;

    public User(String name, String email) {
        this.id = Utils.generateUUID();
        this.createdAt = LocalDateTime.now(ZoneOffset.UTC);
    }
}

我还设置了application.properties关闭日期作为时间戳杰克逊功能:

spring.jackson.serialization.WRITE_DATES_AS_TIMESTAMPS = false

我的maven deps: …

我想尝试JDK 9,我需要修补JCE.我在哪里可以得到JCE zip file for JDK 9？或者我可以使用JDK 8吗？我为JDK 9搜索了JCE zip,但无法找到它.提前致谢.

有没有更优雅的方法在Java 8中实现这一目标？

list.stream()
    .map(e -> myclass.returnsOptional(e))
    .filter(Optional::isPresent)
    .map(Optional::get)
    .collect(Collectors.toList());

我正在谈论filter(Optional::isPresent)随后map(Optional::get),我想优雅地在列表中收集Optional具有值的结果.

我编写了一个流实现,它在文件的行上执行四个简单的缩减(+和<).

起初我执行了四个流,但我决定编写自己的累加器和组合器,以便我可以在一个流中执行所有四个缩减.在小型数据集(10,000,000行)上,运行时间按预期减少到大约1/4,在我的硬件上运行14秒.

fileIn = new BufferedReader(new InputStreamReader(
            new URL(args[0].trim()).openStream()));

final Results results = fileIn.lines()
        .parallel()
        .skip(1)
        .map(User::parse)
        .filter(Optional::isPresent)
        .map(Optional::get)
        .collect(Results::new, Results::accumulate, Results::combine);

Results::accumulate并且分别Results::combine将用户正确地组合到结果和结果与结果中,并且此实现适用于小数据集.

我也试过使用.reduce(),结果很相似,但我试图.collect()减少短期对象的创建.

问题在于,当我使用具有10亿行的真实大小的数据时,我遇到的问题表明Java 8流无法完成任务.在JConsole中观察堆内存,以大致线性方式爬升到分配的12 GB,然后是OOM.

我的印象是收集器或减速器的性能可以与迭代解决方案相媲美,迭代解决方案应该受CPU和IO的限制而不是内存,因为减少步骤产生的结果不会增长,而是减少!

当我进行堆转储并将其放入jhat时,我看到大约7GB被字符串占用,并且这些字符串可以清楚地看作是输入文件的行.我觉得它们根本不应该在内存中,但是jhat显示了一个非常大的ForkJoin相关结构在内存中累积:

Static reference from java.util.concurrent.ForkJoinPool.common (from class java.util.concurrent.ForkJoinPool) :

--> java.util.concurrent.ForkJoinPool@0x786d41db0 (76 bytes) (field workQueues:)
--> [Ljava.util.concurrent.ForkJoinPool$WorkQueue;@0x786eda598 (144 bytes) (Element 3 of [Ljava.util.concurrent.ForkJoinPool$WorkQueue;@0x786eda598:)
--> java.util.concurrent.ForkJoinPool$WorkQueue@0x786d41ee8 (96 bytes) (field currentSteal:)
--> java.util.stream.SliceOps$SliceTask@0x7b4ac6cb0 (130 bytes) (field completer:)
--> java.util.stream.SliceOps$SliceTask@0x7b379ad18 (130 bytes) (field completer:)
--> java.util.stream.SliceOps$SliceTask@0x7b25bdb68 (130 bytes) …

我遇到了一个场景,我想要小写HashMap的所有键(不要问为什么,我只需要这样做).HashMap有数百万条目.

起初,我以为我只是创建一个新的Map,迭代要小写的地图条目,并添加相应的值.这个任务应该每天只运行一次或类似的东西,所以我想我可以裸露这个.

Map<String, Long> lowerCaseMap = new HashMap<>(myMap.size());
for (Map.Entry<String, Long> entry : myMap.entrySet()) {
   lowerCaseMap.put(entry.getKey().toLowerCase(), entry.getValue());
}

但是,当我的服务器在这一次过载时,我正要复制Map时,会导致一些OutOfMemory错误.

现在我的问题是,如何以最小的内存占用来完成这项任务？

在小写后删除每个键 - 添加到新Map帮助？

我可以利用java8流来加快速度吗？(例如这样的事情)

Map<String, Long> lowerCaseMap = myMap.entrySet().parallelStream().collect(Collectors.toMap(entry -> entry.getKey().toLowerCase(), Map.Entry::getValue));

更新 似乎它是一个Collections.unmodifiableMap所以我没有选择

在小写之后移除每个键 - 添加到新地图

我有一个构建列表的方法,我希望它将列表的平均值作为可选值返回.

但是,当我使用Java 8计算平均值时,我总是将返回值作为OptionalDouble.

我该如何转换？

OptionalDouble to Optional<Double>?

以下是我的平均计算代码:

private static Optional<Double> averageListValue() {
     // Build list
     List<Double> testList = new ArrayList<>();
     testList.add(...);
     ...
     ...


     return testList.stream().mapToDouble(value -> value).average();
}

谢谢.

我试图使用java 8收集到ListMultiMap而不使用forEach操作.

如果我在Java 7中编写代码,它将是这样的:

ListMultimap<String, String> result = ArrayListMultimap.create();
     for(State state: states) {
      for(City city: state.getCities()) {
        result.put(state.getName(), city.getName());
      }
    }

我在网上找到了一个网站,讨论如何创建自己的收藏家,以便在这样的场景中使用.我将此实现用于收集器.然后我写了下面的代码:

     ListMultimap<String, String> result = states
        .stream()
        .flatMap(state -> state.getCities().stream()
            .map(city -> {
              return new Pair(state, city);
            }))
        .map(pair -> {
          return new Pair(pair.first().getName(), pair.second().getName()));
        })
        .collect(MultiMapCollectors.listMultimap(
                    Pair::first,
                    Pair::second
                )
        );

但在收集级别,我只能传递一个参数,我似乎找到了传递两个参数的方法.按照网站上的例子,我明白要使用两者,我需要在多图中存储一对"对",如下所示:

ArrayListMultimap<String, Pair> testMap = testObjectList.stream().collect(MultiMapCollectors.listMultimap((Pair p) -> p.first().getName()));

然而,这不是我想要的,我想使用状态的名称和使用java 8的收集器(并且没有forEach)的城市名称收集到ListMultimap中.

有人可以帮助我吗？谢谢!

我在一些项目中看到人们使用Predicates而不是纯if语句,如下面的一个简单示例所示:

    int i = 5;
    // Option 1
    if (i == 5) {
        // Do something
        System.out.println("if statement");
    }

    // Option 2
    Predicate<Integer> predicate = integer -> integer == 5;
    if (predicate.test(i)) {
        // Do something
        System.out.println("predicate");
    }

更喜欢Predicate陈述的重点是什么？