标签: java-8

Java 8引入了重要的新语言功能,例如lambda表达式.

语言中的这些更改是否伴随着编译的字节码中的这些重大更改,这些更改会阻止它在不使用某些反向转换器的情况下在Java 7虚拟机上运行？

我在尝试Java 8的Lambda表达式时遇到了问题.通常它工作正常,但现在我有方法可以抛出IOException.最好看一下以下代码:

class Bank{
    ....
    public Set<String> getActiveAccountNumbers() throws IOException {
        Stream<Account> s =  accounts.values().stream();
        s = s.filter(a -> a.isActive());
        Stream<String> ss = s.map(a -> a.getNumber());
        return ss.collect(Collectors.toSet());
    }
    ....
}

interface Account{
    ....
    boolean isActive() throws IOException;
    String getNumber() throws IOException;
    ....
}

问题是,它不能编译,因为我必须捕获isActive-和getNumber-Methods的可能例外.但即使我明确使用如下所示的try-catch-Block,它仍然无法编译,因为我没有捕获异常.所以要么JDK中存在错误,要么我不知道如何捕获这些异常.

class Bank{
    ....
    //Doesn't compile either
    public Set<String> getActiveAccountNumbers() throws IOException {
        try{
            Stream<Account> s =  accounts.values().stream();
            s = s.filter(a -> a.isActive());
            Stream<String> ss = s.map(a -> a.getNumber());
            return ss.collect(Collectors.toSet());
        }catch(IOException ex){
        } …

我有一个BigDecimals的集合(在这个例子中,a LinkedList)我想加在一起.是否可以使用流？

我注意到这个Stream课有几种方法

Stream::mapToInt
Stream::mapToDouble
Stream::mapToLong

每个都有一个方便的sum()方法.但是,我们知道,float和double算术几乎总是一个坏主意.

那么,有没有一种方便的方法来总结BigDecimals？

这是我到目前为止的代码.

public static void main(String[] args) {
    LinkedList<BigDecimal> values = new LinkedList<>();
    values.add(BigDecimal.valueOf(.1));
    values.add(BigDecimal.valueOf(1.1));
    values.add(BigDecimal.valueOf(2.1));
    values.add(BigDecimal.valueOf(.1));

    // Classical Java approach
    BigDecimal sum = BigDecimal.ZERO;
    for(BigDecimal value : values) {
        System.out.println(value);
        sum = sum.add(value);
    }
    System.out.println("Sum = " + sum);

    // Java 8 approach
    values.forEach((value) -> System.out.println(value));
    System.out.println("Sum = " + values.stream().mapToDouble(BigDecimal::doubleValue).sum());
    System.out.println(values.stream().mapToDouble(BigDecimal::doubleValue).summaryStatistics().toString());
}

正如你所看到的,我正在总结BigDecimals BigDecimal::doubleValue(),但这(正如预期的那样)并不准确.

后代的回答后编辑:

这两个答案都非常有帮助.我想补充一点:我的现实场景不涉及原始集合BigDecimal,它们包含在发票中.但是,通过使用map()流的功能,我能够修改Aman Agnihotri的答案以解决这个问题: …

为什么要使用Objects.requireNonNull()？

我注意到Oracle JDK中使用了许多Java 8方法,如果给定的对象(参数)是NullPointerException内部抛出null的NullPointerException.

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

但是null如果NullPointerException对象被解除引用,则无论如何都会抛出.那么,为什么要进行额外的空检查和抛出 Objects.requireNonNull()？

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

假设我有一个类和一个方法

class A {
  void foo() throws Exception() {
    ...
  }
}

现在我想为A一个流传递的每个实例调用foo,如:

void bar() throws Exception {
  Stream<A> as = ...
  as.forEach(a -> a.foo());
}

问题:如何正确处理异常？代码无法在我的机器上编译,因为我没有处理foo()可能抛出的异常.在throws Exception的bar似乎是没用在这里.这是为什么？

我正在使用java lambda对列表进行排序.

我怎样才能以相反的方式对它进行排序？

我看到这篇文章,但我想使用java 8 lambda.

这是我的代码(我使用*-1)作为黑客

Arrays.asList(files).stream()
    .filter(file -> isNameLikeBaseLine(file, baseLineFile.getName()))
    .sorted(new Comparator<File>() {
        public int compare(File o1, File o2) {
            int answer;
            if (o1.lastModified() == o2.lastModified()) {
                answer = 0;
            } else if (o1.lastModified() > o2.lastModified()) {
                answer = 1;
            } else {
                answer = -1;
            }
            return -1 * answer;
        }
    })
    .skip(numOfNewestToLeave)
    .forEach(item -> item.delete());

我怎样才能优雅地序列化lambda？

例如,下面的代码抛出一个NotSerializableException.如何在不创建SerializableRunnable"虚拟"界面的情况下修复它？

public static void main(String[] args) throws Exception {
    File file = Files.createTempFile("lambda", "ser").toFile();
    try (ObjectOutput oo = new ObjectOutputStream(new FileOutputStream(file))) {
        Runnable r = () -> System.out.println("Can I be serialized?");
        oo.writeObject(r);
    }

    try (ObjectInput oi = new ObjectInputStream(new FileInputStream(file))) {
        Runnable  r = (Runnable) oi.readObject();
        r.run();
    }
}

假设我有一个方法将只读视图返回到成员列表:

class Team {
    private List < Player > players = new ArrayList < > ();

    // ...

    public List < Player > getPlayers() {
        return Collections.unmodifiableList(players);
    }
}

进一步假设所有客户端都立即迭代一次列表.也许将玩家放入JList或其他东西.客户端就不能存储到列表的引用以便稍后进行检查!

鉴于这种常见情况,我应该返回一个流吗？

public Stream < Player > getPlayers() {
    return players.stream();
}

或者在Java中返回非惯用的流？设计的流是否始终在它们创建的同一表达式中"终止"？

在搜索一些代码时,我遇到了箭头操作符,它到底是做什么的？我以为Java没有箭头操作符.

return (Collection<Car>) CollectionUtils.select(listOfCars, (arg0) -> {
        return Car.SEDAN == ((Car)arg0).getStyle();
});

详细信息:Java 6,Apache Commons Collection,IntelliJ 12

更新/答案:事实证明IntelliJ 12支持Java 8,它支持lambdas,并且"折叠"Predicates并将它们显示为lambda.下面是"未折叠"的代码.

return (Collection<Car>) CollectionUtils.select(listOfCars, new Predicate() {
    public boolean evaluate(Object arg0) {
        return Car.SEDAN == ((Car)arg0).getStyle();
    }
});

我有一个对象列表说car.我想基于使用Java 8的一些参数来过滤此列表.但是如果参数是null,它会抛出NullPointerException.如何过滤掉空值？

目前的代码如下

requiredCars = cars.stream().filter(c -> c.getName().startsWith("M"));

NullPointerException如果getName()返回则抛出null.