我知道有很多关于如何在Java中获取日期的问题，但我想要一个使用新的Java 8日期API的例子。我也知道JodaTime库，但我想要一个不依赖于外部库的方法。

该函数需要符合以下限制:

从日期保存时间防止错误 输入是两个日期对象(没有时间，我知道LocalDateTime，但我需要用日期实例这样做)

在Java 8中，我想对一个可选对象做一些事情，如果它是存在的，并做另一件事，如果它不存在。

if (opt.isPresent()) {
  System.out.println("found");
} else {
  System.out.println("Not found");
}

不过，这不是一种“功能性风格”。

Optional有一个ifPresent()方法，但我无法链orElse()方法。

因此，我不能写:

opt.ifPresent( x -> System.out.println("found " + x))
   .orElse( System.out.println("NOT FOUND"));

回复@assylias，我不认为Optional.map()适用于以下情况:

opt.map( o -> {
  System.out.println("while opt is present...");
  o.setProperty(xxx);
  dao.update(o);
  return null;
}).orElseGet( () -> {
  System.out.println("create new obj");
  dao.save(new obj);
  return null;
});

在本例中，当出现opt时，我更新它的属性并保存到数据库。当它不可用时，我创建一个新的obj并保存到数据库。

注意，在两个lambda中，我必须返回null。

但是当opt存在时，两个lambdas都将被执行。Obj将被更新，一个新的对象将被保存到数据库中。这是因为在第一个lambda中返回null。orElseGet()将继续执行。

Java 8最有用的特性之一是接口上新的默认方法。它们被引入的主要原因有两个(可能还有其他原因):

提供实际的默认实现。例如:Iterator.remove () 允许JDK API的发展。例如:Iterable.forEach ()

从API设计者的角度来看，我希望能够在接口方法上使用其他修饰符，例如final。这在添加方便方法时非常有用，可以防止在实现类时发生“意外”重写:

interface Sender {

    // Convenience method to send an empty message
    default final void send() {
        send(null);
    }

    // Implementations should only implement this method
    void send(String message);
}

如果Sender是一个类，上面已经是常见的做法:

abstract class Sender {

    // Convenience method to send an empty message
    final void send() {
        send(null);
    }

    // Implementations should only implement this method
    abstract void send(String message);
}

现在，default和final显然是相互矛盾的关键字，但default关键字本身并不是严格要求的，所以我假设这种矛盾是故意的，以反映“带有主体的类方法”(只是方法)和“带有主体的接口方法”(默认方法)之间的微妙差异，即我还没有理解的差异。

在某些时候，对接口方法上的修饰符(如static和final)的支持还没有完全开发出来，引用Brian Goetz的话:

另一部分是我们将在多大程度上支持班级建设 接口中的工具，如final方法、私有方法、受保护 方法，静态方法等等。答案是:我们还不知道

显然，从2011年末开始，接口中增加了对静态方法的支持。显然，这为JDK库本身增加了很多价值，例如comparator . compare()。

问题:

final(也是静态final)从来没有出现在Java 8接口中的原因是什么?

Map<String, String> phoneBook = people.stream()
                                      .collect(toMap(Person::getName,
                                                     Person::getAddress));

我得到java.lang.IllegalStateException:当找到一个重复的元素时，重复键。

是否有可能忽略这种例外添加值到地图?

当有重复的键时，应该忽略重复的键继续执行。

我试图计算两个LocalDateTime之间的差异。

输出格式为y年m个月d天h小时m分s秒。以下是我所写的:

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.Period;
import java.time.ZoneId;

public class Main {

    static final int MINUTES_PER_HOUR = 60;
    static final int SECONDS_PER_MINUTE = 60;
    static final int SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR;

    public static void main(String[] args) {
        LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 9, 19, 46, 45);
        LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);

        Period period = getPeriod(fromDateTime, toDateTime);
        long time[] = getTime(fromDateTime, toDateTime);

        System.out.println(period.getYears() + " years " + 
                period.getMonths() + " months " + 
                period.getDays() + " days " +
                time[0] + " hours " +
                time[1] + " minutes " +
                time[2] + " seconds.");


    }

    private static Period getPeriod(LocalDateTime dob, LocalDateTime now) {
        return Period.between(dob.toLocalDate(), now.toLocalDate());
    }

    private static long[] getTime(LocalDateTime dob, LocalDateTime now) {
        LocalDateTime today = LocalDateTime.of(now.getYear(),
                now.getMonthValue(), now.getDayOfMonth(), dob.getHour(), dob.getMinute(), dob.getSecond());
        Duration duration = Duration.between(today, now);

        long seconds = duration.getSeconds();

        long hours = seconds / SECONDS_PER_HOUR;
        long minutes = ((seconds % SECONDS_PER_HOUR) / SECONDS_PER_MINUTE);
        long secs = (seconds % SECONDS_PER_MINUTE);

        return new long[]{hours, minutes, secs};
    }
}

我得到的输出是29年8个月24天12小时0分50秒。我已经从这个网站检查了我的结果(值12/16/1984 07:45:55和09/09/2014 19:46:45)。输出结果如下截图所示:

我非常确定，月份值之后的字段在我的代码中是错误的。任何建议都会很有帮助。

更新

我从另一个网站测试了我的结果，得到的结果是不同的。计算两个日期之间的持续时间(结果:29年8个月24天12小时0分50秒)。

更新

由于我从两个不同的网站得到了两个不同的结果，我想知道我的计算算法是否合法。如果我使用以下两个LocalDateTime对象:

LocalDateTime toDateTime = LocalDateTime.of(2014, 9, 10, 6, 40, 45);
LocalDateTime fromDateTime = LocalDateTime.of(1984, 12, 16, 7, 45, 55);

然后输出来了:29年8个月25天-1小时-5分-10秒。

从这个环节开始应该是29年8个月24天22小时54分50秒。所以算法也需要处理负数。

注意，这个问题不是关于哪个站点给了我什么结果，我需要知道正确的算法，需要有正确的结果。

我在Java 8中使用lambda，我遇到警告，从lambda表达式引用的局部变量必须是final或有效的final。我知道当我在匿名类中使用变量时，它们在外部类中必须是final，但final和有效final之间的区别是什么?

我正在看IntStream的文档，我看到一个toArray方法，但没有办法直接到List<Integer>

肯定有一种方法可以将流转换为列表?

我已经注意到Oracle JDK中的许多Java 8方法使用Objects.requireNonNull()，如果给定的对象(参数)为空，它会在内部抛出NullPointerException。

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

但是如果空对象被解引用，无论如何都会抛出NullPointerException。那么，为什么要做这个额外的空检查并抛出 NullPointerException吗?

一个明显的答案(或好处)是它使代码更具可读性，我同意这一点。我很想知道使用的其他原因 方法开头的Objects.requireNonNull()。

我想知道是否有一种方法可以使用Java 8的新的LocalDate, LocalTime或LocalDateTime类来获取自1-1-1970 (epoch)以来的当前毫秒。

已知的方法如下:

long currentMilliseconds = new Date().getTime();

or

long currentMilliseconds = System.currentTimeMillis();

当在Iterable上使用外部迭代时，我们使用break或return from enhanced for-each循环，如下:

for (SomeObject obj : someObjects) {
   if (some_condition_met) {
      break; // or return obj
   }
}

如何在Java 8 lambda表达式中使用内部迭代中断或返回:

someObjects.forEach(obj -> {
   //what to do here?
})