JAVA里的元祖类

什么是元祖类

  java中的方法只能返回单个对象，如果需要返回多个怎么办？通常我们会创建一个额外的对象，或者把返回内容放入集合中返回，另外，我们也有其他的选择：结合泛型，我们可以把一组对象直接打包存储于单一对象中，之后从该对象中读取元素，并能明确知道各元素的类型，安全的使用它们。

  这个概念称为元组，也称为 数据传输对象(即DTO) 或 信使 。

  通常，元组可以具有任意长度，元组中的对象可以是不同类型的。不过，我们希望能够为每个对象指明类型，并且从元组中读取出来时，能够得到正确的类型。要处理不同长度的问题，我们需要创建多个不同的元组。下面是一个可以存储两个对象的元组：

public class Tuple2<A, B> {
  public final A a1;
  public final B a2;
  public Tuple2(A a, B b) { a1 = a; a2 = b; }
}

  public和final的结合保证了元素的可读性和不可修改性。元祖对象的类型组成依赖于传递参数的顺序。

  我们可以利用继承来实现更长的元祖：

public class Tuple3<A, B, C> extends Tuple2<A, B> {
  public final C a3;
  public Tuple3(A a, B b, C c) {
    super(a, b);
    a3 = c;
  }
}

public class Tuple4<A, B, C, D>  extends Tuple3<A, B, C> {
  public final D a4;
  public Tuple4(A a, B b, C c, D d) {
    super(a, b, c);
    a4 = d;
  }
}

  使用元组时，你只需要定义一个长度适合的元组，将其作为返回值即可。注意下面例子中方法的返回类型：

public class TupleTest {
  static Tuple2<String, Integer> f() {
    // 47 自动装箱为 Integer
    return new Tuple2<>("hi", 47);
  }

  static Tuple3<Student, String, Integer> g() {
    return new Tuple3<>(new Student(), "hi", 47);
  }
}

  使用类型参数推断 ，我们可以创建若干重载的静态泛型方法来略去new操作的繁琐性：

public class Tuple {
    public static <A, B> Tuple2<A, B> tuple(A a, B b) {
        return new Tuple2<>(a, b);
    }

    public static <A, B, C> Tuple3<A, B, C>
    tuple(A a, B b, C c) {
        return new Tuple3<>(a, b, c);
    }
}
public class TupleTest {
    static Tuple2<String, Integer> f() {
        return tuple("hi", 47);
    }
   static Tuple3<Student, String, Integer> g() {
        return tuple(new Student(), "hi", 47);
    }
}