如何在Java中实现函数参数的元组解包？
问题描述：
我创建了一些tuple类，并将它们放入Java集合中。但是我不想直接在迭代collection时使用tuple作为函数参数。所以我实现了tuple解包，如下面的代码。如何在Java中实现函数参数的元组解包？
基本上它的工作原理，但问题是，类型转换，需要：
map((Func2<Long, Long, Long>) (a, b) -> a + b)
是否有什么办法可以去除这里的类型转换？
编辑：
也许是我没有说清楚，不仅tuple2，也tuple3，tuple4 ...应予支持。 @飞扬的回答作品大为Tuple2，但tuple2，tuple3，tuple4在此期间不工作
package test;
import com.google.common.collect.Iterables;
import java.util.Arrays;
import java.util.function.Function;
import static test.TupleIterable.Tuple.tuple;
public interface TupleIterable<T> {
Iterable<T> apply();
static <E> TupleIterable<E> from(Iterable<E> iterable) {
return() -> iterable;
}
default <E> TupleIterable<E> map(Function<? super T, ? extends E> op) {
return() -> Iterables.transform(TupleIterable.this.apply(), op::apply);
}
interface Func2<T1, T2, R> extends Function<Tuple.Tuple2<T1, T2>, R> {
R apply(T1 t1, T2 t2);
@Override
default R apply(Tuple.Tuple2<T1, T2> t) {
return apply(t.t1, t.t2);
}
}
interface Func3<T1, T2, T3, R> extends Function<Tuple.Tuple3<T1, T2, T3>, R> {
R apply(T1 t1, T2 t2, T3 t3);
@Override
default R apply(Tuple.Tuple3<T1, T2, T3> t) {
return apply(t.t1, t.t2, t.t3);
}
}
interface Tuple {
static <T1, T2> Tuple2<T1, T2> tuple(T1 t1, T2 t2) {
return new Tuple2<>(t1, t2);
}
static <T1, T2, T3> Tuple3<T1, T2, T3> tuple(T1 t1, T2 t2, T3 t3) {
return new Tuple3<>(t1, t2, t3);
}
class Tuple2<T1, T2> implements Tuple {
public T1 t1;
public T2 t2;
public Tuple2(T1 t1, T2 t2) {
this.t1 = t1;
this.t2 = t2;
}
}
class Tuple3<T1, T2, T3> implements Tuple {
public T1 t1;
public T2 t2;
public T3 t3;
public Tuple3(T1 t1, T2 t2, T3 t3) {
this.t1 = t1;
this.t2 = t2;
this.t3 = t3;
}
}
}
public static void main(String[] args) {
TupleIterable.from(Arrays.asList(1L, 2L))
.map(x -> tuple(x, x)) // map long to tuple2
.map((Func2<Long, Long, Tuple.Tuple3<Long, Long, Long>>) (a, b) -> tuple(a, b, a + b)) // map tuple2 to tuple3
.map((Func3<Long, Long, Long, Long>) (a, b, c) -> a + b + c) // map tuple3 to Long
.apply()
.forEach(System.out::println);
}
}
答
你可以做同样的伎俩为JDK开发者没有为基本类型的Stream专业。在不同的界面中引入mapToTuple和unwrap。
我重写了一些您的代码并使用了一些现有的FunctionalInterfaces。
import java.util.Arrays;
import java.util.Iterator;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
public class Test {
public static void main(String... args) {
MyIterable.from(Arrays.asList(1L, 2L)).mapToTuple(l -> Tuple2.tuple(l, l + 1L)).unwrap((a, b) -> a + b).get()
.forEach(System.out::println);
}
}
final class Tuple2<T1, T2> {
public static <T1, T2> Tuple2<T1, T2> tuple(T1 t1, T2 t2) {
return new Tuple2<>(t1, t2);
}
public final T1 t1;
public final T2 t2;
private Tuple2(T1 t1, T2 t2) {
this.t1 = t1;
this.t2 = t2;
}
}
@FunctionalInterface
interface TupleIterable<T1, T2> extends Supplier<Iterable<Tuple2<T1, T2>>> {
default <E> MyIterable<E> unwrap(BiFunction<T1, T2, E> func) {
return() -> Iterables.transform(get(), t -> func.apply(t.t1, t.t2));
}
}
@FunctionalInterface
interface MyIterable<T> extends Supplier<Iterable<T>> {
static <E> MyIterable<E> from(Iterable<E> iterable) {
return() -> iterable;
}
default <E> MyIterable<E> map(Function<? super T, ? extends E> mapper) {
return() -> Iterables.transform(get(), mapper::apply);
}
default <T1, T2> TupleIterable<T1, T2> mapToTuple(Function<? super T, ? extends Tuple2<T1, T2>> tupleMapper) {
return() -> Iterables.transform(get(), tupleMapper::apply);
}
}
final class Iterables {
public static <T, E> Iterable<E> transform(Iterable<T> iterable, Function<? super T, ? extends E> mapper) {
return() -> new Iterator<E>() {
private final Iterator<T> iter = iterable.iterator();
@Override
public boolean hasNext() {
return iter.hasNext();
}
@Override
public E next() {
return mapper.apply(iter.next());
}
};
}
}
答
我真的不能告诉，如果这是过于“肮脏”或没有，但为什么不为T1和T2提供内部Tuple2 getter和做：
.map(x -> tuple(x, x + 1)) // map long to tuple2
.map(a -> a.getT1() + a.getT2()) // map tuple2 to long
答
而不是做类型转换，我创建了一个unpack函数来解开元组。它的工作原理与类似，但仍不够直观。
package test;
import com.google.common.collect.Iterables;
import java.util.Arrays;
import java.util.function.Function;
import static test.TupleIterable.Func.unpack;
import static test.TupleIterable.Tuple.tuple;
public interface TupleIterable<T> {
Iterable<T> apply();
static <E> TupleIterable<E> from(Iterable<E> iterable) {
return() -> iterable;
}
default <E> TupleIterable<E> map(Function<? super T, E> op) {
return() -> Iterables.transform(TupleIterable.this.apply(), op::apply);
}
interface Func {
static <T1, T2, R> Function<Tuple.Tuple2<T1, T2>, R> unpack(Func2<T1, T2, R> f) {
return t -> f.apply(t.t1, t.t2);
}
static <T1, T2, T3, R> Function<Tuple.Tuple3<T1, T2, T3>, R> unpack(Func3<T1, T2, T3, R> f) {
return t -> f.apply(t.t1, t.t2, t.t3);
}
@FunctionalInterface
interface Func2<T1, T2, R> {
R apply(T1 t1, T2 t2);
}
@FunctionalInterface
interface Func3<T1, T2, T3, R> {
R apply(T1 t1, T2 t2, T3 t3);
}
}
interface Tuple {
static <T1, T2> Tuple2<T1, T2> tuple(T1 t1, T2 t2) {
return new Tuple2<>(t1, t2);
}
static <T1, T2, T3> Tuple3<T1, T2, T3> tuple(T1 t1, T2 t2, T3 t3) {
return new Tuple3<>(t1, t2, t3);
}
class Tuple2<T1, T2> implements Tuple {
public T1 t1;
public T2 t2;
public Tuple2(T1 t1, T2 t2) {
this.t1 = t1;
this.t2 = t2;
}
}
class Tuple3<T1, T2, T3> implements Tuple {
public T1 t1;
public T2 t2;
public T3 t3;
public Tuple3(T1 t1, T2 t2, T3 t3) {
this.t1 = t1;
this.t2 = t2;
this.t3 = t3;
}
}
}
public static void main(String[] args) {
TupleIterable.from(Arrays.asList(1L, 2L))
.map(x -> tuple(x, x)) // map long to tuple2
.map(unpack((a, b) -> tuple(a, b, a + b))) // map tuple2 to tuple3
.map(unpack((a, b, c) -> a + b + c)) // map tuple3 to Long
.apply()
.forEach(System.out::println);
}
}
感谢您的好评！我还有一个问题，这是否支持其他元组，例如'Tuple3'，'Tuple4'等等......看来我需要创建很多方法，比如'mapToTuple3'，'mapToTuple4' ... – moshangcheng
'Tuple3Iterable '，'Tuple4Iterable'不兼容。也就是说，参数不能在'Tuple3Iterable :: mapToTuple4'中解压缩。 – moshangcheng
@moshangcheng如果你想成为通用的，那么你无法避免施放。 – Flown