在开发过程中我们经常遇到一个方法想要返回两个返回值的情况吧,但是
return
语句只允许返回一个对象,虽然我们可以使用数组,map等来返回,但是使用起来还是比较麻烦。而解决办法就是创建一个对象,用它来持有想要返回的对象 ----------------这时就需要元组了。它是将一组对象直接打包存储与其中的一个单一对象.这个容器对象允许读取其中的元素.但是不允许向其中存放新的对象.(这个概念也称为数据传送对象,或信使)。
注: 元组和列表list一样,都可能用于数据存储,包含多个数据;但是和列表不同的是:列表只能存储相同的数据类型,而元组不一样,它可以存储不同的数据类型,比如同时存储int、string、list等,并且可以根据需求无限扩展。
jdk没有元组类型的,下面以jooq为例进行讲解。
package org.jooq.lambda.tuple;
public class Tuple2<T1, T2> implements Tuple, Comparable<Tuple2<T1, T2>>, Serializable, Cloneable {
private static final long serialVersionUID = 1L;
public final T1 v1;
public final T2 v2;
public T1 v1() {
return v1;
}
public T2 v2() {
return v2;
}
public Tuple2(Tuple2<T1, T2> tuple) {
this.v1 = tuple.v1;
this.v2 = tuple.v2;
}
public Tuple2(T1 v1, T2 v2) {
this.v1 = v1;
this.v2 = v2;
}
public final <T3> Tuple3<T1, T2, T3> concat(T3 value) {
return new Tuple3<>(v1, v2, value);
}
public final <T3> Tuple3<T1, T2, T3> concat(Tuple1<T3> tuple) {
return new Tuple3<>(v1, v2, tuple.v1);
}
public final Tuple0 limit0() {
return new Tuple0();
}
public final Tuple1<T1> limit1() {
return new Tuple1<>(v1);
}
public final Tuple2<Tuple0, Tuple2<T1, T2>> split0() {
return new Tuple2<>(limit0(), skip0());
}
public final Tuple2<Tuple1<T1>, Tuple1<T2>> split1() {
return new Tuple2<>(limit1(), skip1());
}
public final Tuple2<T2, T1> swap() {
return new Tuple2<>(v2, v1);
}
...
}
以二元组为例:
Tuple2<People, List<Integer>> tuple2=new Tuple<>(new People(小明), new ArrayList<Integer>(Arrays.asList(1, 10, 20)))二元组变为三元组:
Tuple2<People, List<Integer>,Map<String,Integer>> tuple3=tuple2.cat(Map.of("Hello", 1, "World", 2));
Tuple2<String, Integer> tuple2 = new Tuple2<>("小明", 1);
System.out.println(tuple2);
Tuple3<String, Integer, Boolean> concat = tuple2.concat(true);
System.out.println(concat);
Tuple2<Tuple0, Tuple2<String, Integer>> objects = tuple2.split0();
System.out.println(objects);
Tuple2<Tuple1<String>, Tuple1<Integer>> objects1 = tuple2.split1();
System.out.println(objects1);
Tuple2<Tuple2<String, Integer>, Tuple1<Boolean>> objects2 = concat.split2();
System.out.println(objects2);
输出:
(小明, 1)---二元组
(小明, 1, true)---三元组
((), (小明, 1))---二元组split0
((小明), (1))------二元组split1
((小明, 1), (true))---三元组split2
从源码可以看到,返回的仍然是二元组。其由两个一元组构成.
public final Tuple2<Tuple1<T1>, Tuple1<T2>> split1() {
return new Tuple2<>(limit1(), skip1());
}
public final Tuple1<T1> limit1() {
return new Tuple1<>(v1);
}
public final Tuple1<T2> skip1() {
return new Tuple1<>(v2);
}
交互v1 v2的值,源码:
public final Tuple2<T2, T1> swap() {
return new Tuple2<>(v2, v1);
}
判断两个元组是否重叠
// true
range(1, 3).overlaps(range(2, 4))
// false
range(1, 3).overlaps(range(5, 8))
判断两个元组是否相交
// (2, 3)
range(1, 3).intersect(range(2, 4))
// none
range(1, 3).intersect(range(5, 8))
转化为数组
public final Object[] toArray() {
return new Object[] { v1, v2 };
}
转化为List
public final List<?> toList() {
return Arrays.asList(toArray());
}
转化为流格式,,类似stream
public final Seq<?> toSeq() {
return Seq.seq(toList());
}