小编Stu*_*rks的帖子

Google Guava有一个始终返回true的谓词.Java 8有类似的东西Predicate吗？我知道我可以使用(foo)->{return true;},但我想要预制的东西,类似于Collections.emptySet().

具体来说,我有TabPane,我想知道是否有特定ID的元素.

所以,我想用Java中的lambda表达式做到这一点:

boolean idExists = false;
String idToCheck = "someId";

for (Tab t : tabPane.getTabs()){
    if(t.getId().equals(idToCheck)) {
        idExists = true;
    }
}

Enum类是Serializable,因此使用枚举序列化对象没有问题.另一种情况是class具有java.util.Optional类的字段.在这种情况下,抛出以下异常:java.io.NotSerializableException:java.util.Optional

如何处理这些类,如何序列化它们？是否可以将此类对象发送到远程EJB或通过RMI？

这是一个例子:

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Optional;

import org.junit.Test;

public class SerializationTest {

    static class My implements Serializable {

        private static final long serialVersionUID = 1L;
        Optional<Integer> value = Optional.empty();

        public void setValue(Integer i) {
            this.i = Optional.of(i);
        }

        public Optional<Integer> getValue() {
            return value;
        }
    }

    //java.io.NotSerializableException is thrown

    @Test
    public void serialize() {
        My my = new My();
        byte[] bytes = toBytes(my);
    }

    public static <T extends Serializable> byte[] toBytes(T reportInfo) { …

如何获得与流中的条件匹配的第一个元素？我试过这个但是没用

this.stops.stream().filter(Stop s-> s.getStation().getName().equals(name));

该条件不起作用,filter方法在Stop之外的其他类中调用.

public class Train {

private final String name;
private final SortedSet<Stop> stops;

public Train(String name) {
    this.name = name;
    this.stops = new TreeSet<Stop>();
}

public void addStop(Stop stop) {
    this.stops.add(stop);
}

public Stop getFirstStation() {
    return this.getStops().first();
}

public Stop getLastStation() {
    return this.getStops().last();
}

public SortedSet<Stop> getStops() {
    return stops;
}

public SortedSet<Stop> getStopsAfter(String name) {


    // return this.stops.subSet(, toElement);
    return null;
}
}


import java.util.ArrayList;
import java.util.List;

public class Station {
private final …

修改局部变量forEach会产生编译错误:

正常

    int ordinal = 0;
    for (Example s : list) {
        s.setOrdinal(ordinal);
        ordinal++;
    }

随着Lambda

    int ordinal = 0;
    list.forEach(s -> {
        s.setOrdinal(ordinal);
        ordinal++;
    });

知道如何解决这个问题吗？

Stream作为非终端操作,如何检查a 是否为空并抛出异常(如果不是)？

基本上,我正在寻找与下面的代码等效的东西,但没有实现中间的流.特别是,在终端操作实际消耗流之前不应进行检查.

public Stream<Thing> getFilteredThings() {
    Stream<Thing> stream = getThings().stream()
                .filter(Thing::isFoo)
                .filter(Thing::isBar);
    return nonEmptyStream(stream, () -> {
        throw new RuntimeException("No foo bar things available")   
    });
}

private static <T> Stream<T> nonEmptyStream(Stream<T> stream, Supplier<T> defaultValue) {
    List<T> list = stream.collect(Collectors.toList());
    if (list.isEmpty()) list.add(defaultValue.get());
    return list.stream();
}

你好Java开发人员,

我知道主题可能有点 in advance因为JDK8尚未发布(现在还不是.)但我正在阅读一些关于Lambda表达式的文章,特别是与新集合API相关的部分,称为Stream.

以下是Java Magazine文章中给出的示例(它是一个水獭种群算法..):

Set<Otter> otters = getOtters();
System.out.println(otters.stream()
    .filter(o -> !o.isWild())
    .map(o -> o.getKeeper())
    .filter(k -> k.isFemale())
    .into(new ArrayList<>())
    .size());

我的问题是如果在Set内部迭代的中间,其中一个otter为null会发生什么？

我希望抛出NullPointerException,但也许我仍然坚持以前的开发范例(非功能),有人可以启发我应该如何处理它？

如果这确实抛出了NullPointerException,我发现该功能非常危险,只能如下所示:

• 开发人员确保没有空值(可能使用以前的.filter(o - > o!= null))
• 开发人员确保应用程序永远不会生成null otter或特殊的NullOtter对象来处理.

什么是最佳选择,或任何其他选择？

谢谢!

假设我有一个使用lambda表达式(闭包)定义的对象列表.有没有办法检查它们,以便可以进行比较？

我最感兴趣的代码是

    List<Strategy> strategies = getStrategies();
    Strategy a = (Strategy) this::a;
    if (strategies.contains(a)) { // ...

完整的代码是

import java.util.Arrays;
import java.util.List;

public class ClosureEqualsMain {
    interface Strategy {
        void invoke(/*args*/);
        default boolean equals(Object o) { // doesn't compile
            return Closures.equals(this, o);
        }
    }

    public void a() { }
    public void b() { }
    public void c() { }

    public List<Strategy> getStrategies() {
        return Arrays.asList(this::a, this::b, this::c);
    }

    private void testStrategies() {
        List<Strategy> strategies = getStrategies();
        System.out.println(strategies);
        Strategy a = (Strategy) …

为了帮助理解monad是什么,有人可以使用java提供一个例子吗？他们有可能吗？

如果你从这里下载预发布的lambda兼容JDK8,可以使用java表达lambda表达式http://jdk8.java.net/lambda/

使用此JDK的lambda示例如下所示,有人可以提供相对简单的monad吗？

public interface TransformService {
        int[] transform(List<Integer> inputs);
    }
    public static void main(String ars[]) {
        TransformService transformService = (inputs) -> {
            int[] ints = new int[inputs.size()];
            int i = 0;
            for (Integer element : inputs) {
                ints[i] = element;
            }
            return ints;
        };

        List<Integer> inputs = new ArrayList<Integer>(5) {{
            add(10);
            add(10);
        }};
        int[] results = transformService.transform(inputs);
    }

就像几乎所有人一样,我仍然在学习新的Java 8 Streams API的复杂性(并且非常喜欢它们).我有一个关于流的使用的问题.我将提供一个简化的例子.

Java Streams允许我们使用a Collection,并使用stream()它上面的方法来接收所有元素的流.在这,有许多有用的方法,比如filter(),map()和forEach(),这让我们对内容的使用拉姆达操作.

我的代码看起来像这样(简化):

set.stream().filter(item -> item.qualify())
    .map(item -> (Qualifier)item).forEach(item -> item.operate());
set.removeIf(item -> item.qualify());

我们的想法是获取集合中所有项目的映射,这些项目匹配某个限定符,然后通过它们进行操作.操作后,它们不再用于其他目的,应从原始组中移除.代码运作良好,但我无法摆脱这样的感觉,即有一个操作Stream可以在一行中为我做这件事.

如果它在Javadocs中,我可能会忽略它.

是否有人更熟悉API会看到类似的东西？