标签: java-8

我想知道如果有一种方法,因为1970年1月1日(时期),以获得当前毫秒使用新的LocalDate,LocalTime或LocalDateTimeJava的8类.

已知的方法如下:

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

要么

long currentMilliseconds = System.currentTimeMillis();

我想用

java.util.Optional.orElseThrow()

使用Exception类型请求构造函数参数.像这样的东西:

orElseThrow(MyException::new(someArgument)) // obviously NOT working

有没有办法创建一个传递我的参数值的供应商？

现在已经使用Java 8超过6个月左右,我对新的API更改感到非常满意.我仍然不自信的一个领域是什么时候使用Optional.我似乎想要在任何可能的null地方使用它,而且无处可去.

似乎有很多情况我可以使用它,我不知道它是否增加了好处(可读性/无效安全性)或只是导致额外的开销.

所以,我有一些例子,我对社区是否Optional有益的想法感兴趣.

1 - 当方法可以返回时作为公共方法返回类型null:

public Optional<Foo> findFoo(String id);

2 - 当参数可能是null以下时作为方法参数:

public Foo doSomething(String id, Optional<Bar> barOptional);

3 - 作为bean的可选成员:

public class Book {

  private List<Pages> pages;
  private Optional<Index> index;

}

4 - 在Collections:

一般来说,我不认为:

List<Optional<Foo>>

添加任何东西 - 特别是因为可以使用filter()删除null值等,但是Optional在集合中是否有任何好的用途？

我错过了什么案例？

在Java 8中,我想对一个Optional对象做一些事情,如果它存在,并做另一件事,如果它不存在.

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将更新,并将新对象保存到数据库.这是因为return null在第一个lambda中.并且orElseGet()将继续执行.

我想知道为什么Iterable界面不提供stream()和parallelStream()方法.考虑以下课程:

public class Hand implements Iterable<Card> {
    private final List<Card> list = new ArrayList<>();
    private final int capacity;

    //...

    @Override
    public Iterator<Card> iterator() {
        return list.iterator();
    }
}

这是一个Hand的实现,因为你可以在玩卡片游戏时手中拿着牌.

基本上它包装a List<Card>,确保最大容量并提供一些其他有用的功能.最好直接实现它作为一个List<Card>.

现在,为了方便起见,我认为实现它会很好Iterable<Card>,这样如果你想循环它就可以使用增强的for循环.(我的Hand班级也提供了一种get(int index)方法,因此Iterable<Card>在我看来是合理的.)

该Iterable接口提供以下内容(省略javadoc):

public interface Iterable<T> {
    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    default Spliterator<T> …

我试图计算两者之间的差异LocalDateTime.

输出必须是格式y years m months d days h hours m minutes s seconds.这是我写的:

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); …

与C#不同IEnumerable,执行管道可以根据需要执行多次,在Java中,流只能"迭代"一次.

对终端操作的任何调用都会关闭流,使其无法使用.这个"功能"消耗了很多力量.

我想这个的原因不是技术性的.这个奇怪限制背后的设计考虑是什么？

编辑:为了演示我在说什么,请考虑以下C#中的Quick-Sort实现:

IEnumerable<int> QuickSort(IEnumerable<int> ints)
{
  if (!ints.Any()) {
    return Enumerable.Empty<int>();
  }

  int pivot = ints.First();

  IEnumerable<int> lt = ints.Where(i => i < pivot);
  IEnumerable<int> gt = ints.Where(i => i > pivot);

  return QuickSort(lt).Concat(new int[] { pivot }).Concat(QuickSort(gt));
}

现在可以肯定的是,我并不是说这是一个很好的快速排序!然而,它是lambda表达式与流操作相结合的表达能力的一个很好的例子.

它不能用Java完成!我甚至无法询问流是否为空而不使其无法使用.

所以我前一段时间安装了JDK 8测试版以查看一些示例.我现在肯定地想,很容易在版本之间进行更改.

使用IntelliJ进行一些Play开发.出于某种原因,IntelliJ正在使用8进行编译,即使:

• 我在Preferences中设置了编译器以使用1.6
• 据说它通过外部构建使用SBT,但命令行的sbt工作
• JAVA_HOME指向JDK 6.

如果我转到Java首选项页面,它确实显示已安装8,但没有选项可以卸载它,它没有看到任何其他版本.

当我这样做时which java,它告诉我/usr/bin/java和我这样做/usr/bin/java -version,它返回1.6.

注意:有点小小的,你可以使用IntelliJ和JDK7,见这里.

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

重复发生时,我得到重复的密钥异常.

是否可以忽略在重复发生时将值添加到映射？

当存在重复时,它应该继续忽略该重复键.

新的Java 8流框架和朋友们制作了一些非常简洁的Java代码,但是我遇到了一个看似简单的情况,简单易懂.

考虑一个List<Thing> things方法Optional<Other> resolve(Thing thing).我想将Things 映射到Optional<Other>s并获得第一个Other.显而易见的解决方案是使用things.stream().flatMap(this::resolve).findFirst(),但flatMap要求您返回一个流,并且Optional没有stream()方法(或者它是Collection一个方法或提供将其转换为或以其方式查看的方法Collection).

我能想到的最好的是:

things.stream()
    .map(this::resolve)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .findFirst();

但这似乎是一个非常普遍的案例,似乎非常冗长.谁有更好的主意？