Java 1.7中的函数（转换Lambda表达式）

huangapple
go评论107阅读模式
英文:

Java Function in 1.7 (convert lambda expressions)

问题

抱歉，我无法提供代码翻译，因为代码的结构和语法需要精确的转换，而不仅仅是文本的翻译。如果您需要将Java 1.8+的lambda表达式转换为Java 1.7，您可能需要重新编写这些表达式，使用Java 1.7支持的传统的匿名内部类来代替。这需要更详细的代码重构，而不仅仅是翻译。

如果您需要帮助将特定的lambda表达式重写为Java 1.7兼容的代码，请提供特定的lambda表达式，我将尽力为您提供相应的建议。

英文:

I am working on an old java application that uses Java 1.7. I would like to make use of the java.util.function.Function interface. However, this is only supported in Java 1.8+.

So I would like to write my own implementation in Java 1.7.

  1. import java.util.Objects;
  3. public interface Function<T, R> {
  4.     
  5.     R apply(T t);
  6.     
  7.     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
  8.         Objects.requireNonNull(before);
  9.         return (V v) -> apply(before.apply(v)); // lambda expression
  10.     }
  11.     
  12.     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
  13.         Objects.requireNonNull(after);
  14.         return (T t) -> after.apply(apply(t)); // lambda expression
  15.     }
  16.     
  17.     static <T> Function<T, T> identity() {
  18.         return t -> t; // lambda expression
  19.     }
  20. }

The above gives me compile errors on the lambda expressions.

Question

How do I write the above lambda expressions in Java 1.7?

答案1

得分: 2

由于你实际上不能创建带有默认方法的接口，我认为你最好的选择是使用静态方法。

  1. public interface Function<T, R> {
  2.     R apply(T t);
  4.     public static <T, V, R> Function<V, R> compose(Function<? super V, ? extends T> before, Function<? super T, ? super R> after) {
  5.         return new CombiningFunction<T, V, R>(before, after);
  6.     }
  7.     
  8.     public static <T, R, V> Function<T, V> andThen(Function<? super T, ? super R> before, Function<? super R, ? extends V> after) {
  9.         return new CombiningFunction<T, V, R>(before, after);
  10.     }
  11.     
  12.     static <T> Function<T, T> identity() {
  13.         return new Function<T, T> {
  14.             T apply(T t) { return t; }
  15.         };
  16.     }
  17. }
  19. class CombiningFunction<T, V, R> implements Function<T, R> {
  20.     Function<T, V> first;
  21.     Function<V, R> second;
  23.     public R apply(T t) {
  24.         V intermediate = first.apply(t);
  25.         return second.apply(intermediate);
  26.     }
  27. }

但正如KarelG在评论中提到的那样，这确实不是一个明智的做法；更不用说这远不及Java 8中的优雅；毕竟，函数接口基本上是为了Lambda而设计的，如果你没有Lambda，所有的用法都会像上面的实现一样笨拙。

英文:

Since you can't actually create an interface with default methods, I think your best chance are static methods.

  1. public interface Function&lt;T, R&gt; {
  2.     R apply(T t);
  4.     public static &lt;T, V, R&gt; Function&lt;V, R&gt; compose(Function&lt;? super V, ? extends T&gt; before, Function&lt;? super T, ? super R&gt; after) {
  5.         return new CombiningFunction&lt;T, V, R&gt;(before, after);
  6.     }
  7.     
  8.     public static &lt;T, R, V&gt; Function&lt;T, V&gt; andThen(Function&lt;? super T, ? super R&gt; before, Function&lt;? super R, ? extends V&gt; after) {
  9.         return new CombiningFunction&lt;T, V, R&gt;(before, after);
  10.     }
  11.     
  12.     static &lt;T&gt; Function&lt;T, T&gt; identity() {
  13.         return new Function&lt;T, T&gt; {
  14.             T apply(T t) { return t; }
  15.         }
  16.     }
  17. }
  19. class CombiningFunction&lt;T, V, R&gt; implements Function&lt;T, R&gt; {
  20.     Function&lt;T, V&gt; first;
  21.     Function&lt;V, R&gt; second;
  23.     public R apply(T t) {
  24.         V intermediate = first.apply(t);
  25.         return second.apply(intermediate);
  26.     }
  27. }

But like KarelG mentions in the comments, it's really not advisable to do this; not to mention that this isn't nearly as elegant as in Java 8; after all, functional interfaces are pretty much geared towards lambdas, and if you don't have them, all usage will be as awkward as the implementation above.

答案2

得分: 1

你可以使用 IntellijIdea 自动更改它，这是 IntellijIdea 的结果：

  1. import java.util.Objects;
  3. public interface Function<T, R> {
  5.     R apply(T t);
  7.     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
  8.         Objects.requireNonNull(before);
  9.         return new Function<V, R>() {
  10.             @Override
  11.             public R apply(V v) {
  12.                 return Function.this.apply(before.apply(v));
  13.             }
  14.         }; // lambda expression
  15.     }
  17.     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
  18.         Objects.requireNonNull(after);
  19.         Function<T, V> tvFunction = new Function<T, V>() {
  20.             @Override
  21.             public V apply(T t) {
  22.                 return after.apply(Function.this.apply(t));
  23.             }
  24.         };
  25.         return tvFunction; // lambda expression
  26.     }
  28.     static <T> Function<T, T> identity() {
  29.         return new Function<T, T>() {
  30.             @Override
  31.             public T apply(T t) {
  32.                 return t;
  33.             }
  34.         }; // lambda expression
  35.     }
  36. }

请注意，我已经保留了原始的代码格式和标记。

英文:

You can use IntellijIdea to change it automatically, There is a result of IntellijIdea:

  1. import java.util.Objects;
  3. public interface Function&lt;T, R&gt; {
  5.     R apply(T t);
  7.     default &lt;V&gt; Function&lt;V, R&gt; compose(Function&lt;? super V, ? extends T&gt; before) {
  8.         Objects.requireNonNull(before);
  9.         return new Function&lt;V, R&gt;() {
  10.             @Override
  11.             public R apply(V v) {
  12.                 return Function.this.apply(before.apply(v));
  13.             }
  14.         }; // lambda expression
  15.     }
  17.     default &lt;V&gt; Function&lt;T, V&gt; andThen(Function&lt;? super R, ? extends V&gt; after) {
  18.         Objects.requireNonNull(after);
  19.         Function&lt;T, V&gt; tvFunction = new Function&lt;T, V&gt;() {
  20.             @Override
  21.             public V apply(T t) {
  22.                 return after.apply(Function.this.apply(t));
  23.             }
  24.         };
  25.         return tvFunction; // lambda expression
  26.     }
  28.     static &lt;T&gt; Function&lt;T, T&gt; identity() {
  29.         return new Function&lt;T, T&gt;() {
  30.             @Override
  31.             public T apply(T t) {
  32.                 return t;
  33.             }
  34.         }; // lambda expression
  35.     }
  36. }

huangapple
  • 本文由 发表于 2020年8月4日 15:40:03
  • 转载请务必保留本文链接：https://go.coder-hub.com/63242214.html
  • java
  • java-7
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定