如何执行Java lambda函数分解

我一直在学习如何使用

和
和
compose
函数组合lambda表达式，例如：

Function<SceneObject> transform = scaleX2.andThen(scaleY2).andThen(rotateZ45);

Function transform=scaleX2.然后（scaleY2）.然后（rotateZ45）；

是否有方法删除结果函数中的一个步骤

因此，在上面的示例中，
transform.decompose（scaleY2）
将导致
transform=scaleX2。然后（rotateZ45）
不使用该代码<代码>函数。然后通过构造lambda表达式来实现
，该表达式完全隐藏了用于构造它的两个函数的细节

另一种方法是使用您自己的类型，例如
Transform
，它可以包装等价的函数，然后支持分解操作

import java.util.Optional;

@FunctionalInterface
public interface Transform<T, R> {
    class AndThen<T, R, S> implements Transform<T, S> {
        final Transform<T, R> first;
        final Transform<R, S> second;

        AndThen(Transform<T, R> first, Transform<R, S> second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public S apply(T t) {
            return second.apply(first.apply(t));
        }

        @Override
        public <U> Optional<Transform<T, U>> decomposeFst() {
            return Optional.of((Transform<T, U>)first);
        }
        @Override
        public <U> Optional<Transform<U, S>> decomposeSnd() {
            return Optional.of((Transform<U, S>)second);
        }

    }

    default <S> Transform<T, S> andThen(Transform<R, S> next) {
        return new AndThen<T, R, S>(this, next);
    }

    R apply(T t);

    default <S> Optional<Transform<T, S>> decomposeFst() {
        return Optional.empty();
    }

    default <S> Optional<Transform<S, R>> decomposeSnd() {
        return Optional.empty();
    }

    static void main(String[] args) {
        final Transform<Double, String> f = Object::toString;
        final Transform<String, Integer> g = String::length;
        final Transform<Double, Integer> h = f.andThen(g);
        final int i = h.apply(1.234);

        final Optional<Transform<Double, String>> f2 = h.<String>decomposeFst();
        final Optional<Transform<String, Integer>> g2 = h.<String>decomposeSnd();

        final String s = f2.get().apply(1.234);
        final int j = g2.get().apply(s);

        System.out.println(s + " : " + j);
    }
}

import java.util.Optional；
@功能接口
公共接口转换{
类，然后实现转换{
最终转换优先；
最终转换秒；
然后（先变换，再变换）{
this.first=first；
这个秒=秒；
}
@凌驾
公共服务申请（T）{
返回second.apply（first.apply（t））；
}
@凌驾
公共可选decomposeFst（）{
返回可选的。of（（转换）first）；
}
@凌驾
公共可选decomposeSnd（）{
返回可选的.of（（转换）秒）；
}
}
默认转换和第二次（转换下一步）{
返回新的，然后（这个，下一个）；
}
R应用（T）；
默认可选的decomposeFst（）{
返回可选的.empty（）；
}
默认可选decomposeSnd（）{
返回可选的.empty（）；
}
静态void main（字符串[]参数）{
最终转换f=对象：：toString；
最终转换g=字符串：：长度；
最终变换h=f，第三次（g）；
最终积分i=h.apply（1.234）；
最终可选f2=h.decomposeFst（）；
最终可选g2=h.decomposeSnd（）；
最后一个字符串s=f2.get（）.apply（1.234）；
final int j=g2.get（）.apply；
System.out.println（s+“：”+j）；
}
}
不使用该代码<代码>函数。然后通过构造lambda表达式来实现

，该表达式完全隐藏了用于构造它的两个函数的细节

另一种方法是使用您自己的类型，例如

Transform

，它可以包装等价的函数，然后支持分解操作

import java.util.Optional;

@FunctionalInterface
public interface Transform<T, R> {
    class AndThen<T, R, S> implements Transform<T, S> {
        final Transform<T, R> first;
        final Transform<R, S> second;

        AndThen(Transform<T, R> first, Transform<R, S> second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public S apply(T t) {
            return second.apply(first.apply(t));
        }

        @Override
        public <U> Optional<Transform<T, U>> decomposeFst() {
            return Optional.of((Transform<T, U>)first);
        }
        @Override
        public <U> Optional<Transform<U, S>> decomposeSnd() {
            return Optional.of((Transform<U, S>)second);
        }

    }

    default <S> Transform<T, S> andThen(Transform<R, S> next) {
        return new AndThen<T, R, S>(this, next);
    }

    R apply(T t);

    default <S> Optional<Transform<T, S>> decomposeFst() {
        return Optional.empty();
    }

    default <S> Optional<Transform<S, R>> decomposeSnd() {
        return Optional.empty();
    }

    static void main(String[] args) {
        final Transform<Double, String> f = Object::toString;
        final Transform<String, Integer> g = String::length;
        final Transform<Double, Integer> h = f.andThen(g);
        final int i = h.apply(1.234);

        final Optional<Transform<Double, String>> f2 = h.<String>decomposeFst();
        final Optional<Transform<String, Integer>> g2 = h.<String>decomposeSnd();

        final String s = f2.get().apply(1.234);
        final int j = g2.get().apply(s);

        System.out.println(s + " : " + j);
    }
}

import java.util.Optional；
@功能接口
公共接口转换{
类，然后实现转换{
最终转换优先；
最终转换秒；
然后（先变换，再变换）{
this.first=first；
这个秒=秒；
}
@凌驾
公共服务申请（T）{
返回second.apply（first.apply（t））；
}
@凌驾
公共可选decomposeFst（）{
返回可选的。of（（转换）first）；
}
@凌驾
公共可选decomposeSnd（）{
返回可选的.of（（转换）秒）；
}
}
默认转换和第二次（转换下一步）{
返回新的，然后（这个，下一个）；
}
R应用（T）；
默认可选的decomposeFst（）{
返回可选的.empty（）；
}
默认可选decomposeSnd（）{
返回可选的.empty（）；
}
静态void main（字符串[]参数）{
最终转换f=对象：：toString；
最终转换g=字符串：：长度；
最终变换h=f，第三次（g）；
最终积分i=h.apply（1.234）；
最终可选f2=h.decomposeFst（）；
最终可选g2=h.decomposeSnd（）；
最后一个字符串s=f2.get（）.apply（1.234）；
final int j=g2.get（）.apply；
System.out.println（s+“：”+j）；
}
}

谁说这是可能的？如果

scaleY2

是

Integer:：parseInt

，而

rotateZ45

是

Math:：abs

，该怎么办？幸运的是，你不能做这样的事情，因为这会导致可怕的无法维护的代码。如果从另一个功能的中间删除一个功能，那就太幸运了。在你上面的例子中，这可能是有意义的，因为你知道不同的部分是什么，但一般来说，你不会也不可能知道另一个函数可能由什么函数组成，也可能不由什么函数组成。谁说这是可能的？如果

scaleY2

是

Integer:：parseInt

，而

rotateZ45

是

Math:：abs

，该怎么办？幸运的是，你不能做这样的事情，因为这会导致可怕的无法维护的代码。如果从另一个功能的中间删除一个功能，那就太幸运了。在上面的例子中，这可能是有意义的，因为您知道不同的部分是什么，但一般来说，您不会也无法知道另一个函数可能由哪些函数组成，也可能不由哪些函数组成。