使用Java lambda而不是“if-else”

Question

对于Java 8，我有以下代码：

if(element.exist()){
    // Do something
}

我想转换成lambda风格，

element.ifExist(el -> {
    // Do something
});

使用像这样的< code>ifExist方法:

public void ifExist(Consumer<Element> consumer) {
    if (exist()) {
        consumer.accept(this);
    }
}

但现在我还有其他案例可以调用：

element.ifExist(el -> {
    // Do something
}).ifNotExist(el -> {
    // Do something
});

我可以写一个类似的< code>ifNotExist，我希望它们是互斥的(如果< code>Exist条件为真，就不需要检查< code>ifNotExist，因为有时候，exist()方法检查起来工作量太大)，但是我总是要检查两次。我该如何避免呢？

也许“存在”这个词让人误解了我的想法。你可以想象我也需要一些方法：

ifVisible()
ifEmpty()
ifHasAttribute()

很多人说这是个坏主意，但是：

在Java8中，我们可以使用lambda foreach而不是传统的for循环。在编程for和if是两个基本的流控制。如果我们可以将lambda用于for循环，为什么将lambda用于if是个坏主意？

for (Element element : list) {
    element.doSomething();
}

list.forEach(Element::doSomething);

在Java 8中，ifPresent有< code>Optional,类似于我对ifExist的想法:

Optional<Elem> element = ...
element.ifPresent(el -> System.out.println("Present " + el);

关于代码维护和易读性，如果我有以下代码，其中有许多重复的简单if子句，你会怎么想？

if (e0.exist()) {
    e0.actionA();
} else {
    e0.actionB();
}

if (e1.exist()) {
    e0.actionC();
}

if (e2.exist()) {
    e2.actionD();
}

if (e3.exist()) {
    e3.actionB();
}

比较：

e0.ifExist(Element::actionA).ifNotExist(Element::actionB);
e1.ifExist(Element::actionC);
e2.ifExist(Element::actionD);
e3.ifExist(Element::actionB);

哪个更好？还有，哎呀，你注意到在传统的if子句代码中，有一个错误：

if (e1.exist()) {
    e0.actionC(); // Actually e1
}

我认为如果我们使用lambda，我们可以避免这个错误！

Answer 1

您可以使用采用两个使用者的单个方法：

public void ifExistOrElse(Consumer<Element> ifExist, Consumer<Element> orElse) {
    if (exist()) {
        ifExist.accept(this);
    } else {
        orElse.accept(this);
    }
}

然后用以下方式调用：

element.ifExistOrElse(
  el -> {
    // Do something
  },
  el -> {
    // Do something else
  });

Answer 2

它被称为“流畅的界面”。只需更改返回类型并返回此值;以允许您链接这些方法：

public MyClass ifExist(Consumer<Element> consumer) {
    if (exist()) {
        consumer.accept(this);
    }
    return this;
}

public MyClass ifNotExist(Consumer<Element> consumer) {
    if (!exist()) {
        consumer.accept(this);
    }
    return this;
}

您可以得到一个更高级的，并返回一个中间类型：

interface Else<T>
{
    public void otherwise(Consumer<T> consumer); // 'else' is a keyword
}

class DefaultElse<T> implements Else<T>
{
    private final T item;

    DefaultElse(final T item) { this.item = item; }

    public void otherwise(Consumer<T> consumer)
    {
        consumer.accept(item);
    }
}

class NoopElse<T> implements Else<T>
{
    public void otherwise(Consumer<T> consumer) { }
}

public Else<MyClass> ifExist(Consumer<Element> consumer) {
    if (exist()) {
        consumer.accept(this);
        return new NoopElse<>();
    }
    return new DefaultElse<>(this);
}

样品用法：

element.ifExist(el -> {
    //do something
})
.otherwise(el -> {
    //do something else
});

Answer 3

由于它几乎但并不完全匹配可选，也许您可能会重新考虑逻辑：

Java 8的表达能力有限：

Optional<Elem> element = ...
element.ifPresent(el -> System.out.println("Present " + el);
System.out.println(element.orElse(DEFAULT_ELEM));

在这里，地图可能会限制元素上的视图：

element.map(el -> el.mySpecialView()).ifPresent(System.out::println);

Java9：

element.ifPresentOrElse(el -> System.out.println("Present " + el,
                        () -> System.out.println("Not present"));

一般来说，这两个分支是不对称的。