JOOQ之Tuple

元组：

在开发过程中我们经常遇到一个方法想要返回两个返回值的情况吧，但是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));

skip

  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);
    }

swap

交互v1 v2的值，源码：

public final Tuple2<T2, T1> swap() {
        return new Tuple2<>(v2, v1);
    }

overlaps

判断两个元组是否重叠

       // true
       range(1, 3).overlaps(range(2, 4))
      
       // false
       range(1, 3).overlaps(range(5, 8))

intersect

判断两个元组是否相交

		// (2, 3)
       range(1, 3).intersect(range(2, 4))
      
       // none
       range(1, 3).intersect(range(5, 8))

toArray

转化为数组

 public final Object[] toArray() {
        return new Object[] { v1, v2 };
    }

toList

转化为List

 public final List<?> toList() {
        return Arrays.asList(toArray());
    }

toSeq

转化为流格式，，类似stream

public final Seq<?> toSeq() {
        return Seq.seq(toList());
    }