一个元组类库
仅一次方法调用就能返回多个对象，作为我们需要的一个功能呢，这在动态语言上非常常见。可是Java这种静态类型的语言，return语句只允许返回单个对象。而解决方法往往是通过创建一个类，用它来持有其所有返回的多个对象。
当然，在每次需要的时候，可以专门通过创建一个类来工作，但是有了泛型以后，我们就能够一次性的解决这个问题，并且不用在这个问题上浪费时间。同时，我们在编译器就能确保类型安全。
元组的概念
元组及将一组对象直接打包，并且储存于其中的一个单一对象。这个容器元素允许读取其中元素，但是不允许向其中存放新的对象。(这个概念也被称为数据传递对象或者信使)。
通常，元组可以具有任意的长度，同时，元组中的对象可以是任意不同的类型。不过我们希望可以为每一个对象指明其类型，并且从容器中读取出来的时候，能够得到正确的类型。
泛型中要处理不同长度的问题，我们需要创建多个元组来实现。下面是一个2维元组，它能够持有两个对象。
public class TwoTuple<A, B> {
public final A first;
public final B second;
public TwoTuple(A first, B second) {
this.first = first;
this.second = second;
}
@Override
public String toString() {
return "(" + getTupleString() + ")";
}
protected String getTupleString() {
return first + ", " + second;
}
}
TwoTuple中通过构造器捕获了要存储的对象，而toString是一个便利的函数，用来显示列表中的值，并隐含地保持了其中元素的次序。
为了安全性考虑，上面的
first和second字段都声明了final对象，这意味者着两个变量赋值后无法被改变，在不用实现get和set方法的情况同时保证了安全。
我们可以利用继承机制实现更长的数组, 增加类型参数是件很简单的事情。
public class ThreeTuple<A,B,C> extends TwoTuple<A,B>{
public final C third;
public ThreeTuple(A first, B second, C third) {
super(first, second);
this.third = third;
}
@Override
protected String getTupleString() {
return super.getTupleString() + ", " + third;
}
}
public class FourTuple<A,B,C,D> extends ThreeTuple<A,B,C>{
public D fourth;
public FourTuple(A first, B second, C third, D fourth) {
super(first, second, third);
this.fourth = fourth;
}
@Override
protected String getTupleString() {
return super.getTupleString() + ", " + fourth;
}
}
public class FiveTuple<A,B,C,D,E> extends FourTuple<A,B,C,D>{
public E fifth;
public FiveTuple(A first, B second, C third, D fourth, E fifth) {
super(first, second, third, fourth);
this.fifth = fifth;
}
@Override
protected String getTupleString() {
return super.getTupleString() + ", " + fifth;
}
}
而为了使用元组，你只需定义一个合适长度的数组，并将其作为方法的返回值，然后在return语句中创建该元组并返回。
public class TupleTest {
static TwoTuple<String,Integer> f(){
return new TwoTuple<>("hi",47);
}
static ThreeTuple<Amphibian,String,Integer> g(){
return new ThreeTuple<>(new Amphibian(),"h1",47);
}
static FourTuple<Vehicle,Amphibian,String,Integer> h(){
return new FourTuple<>(new Vehicle(),new Amphibian(),"h1",47);
}
static FiveTuple<Vehicle,Amphibian,String,Integer,Double> k(){
return new FiveTuple<>(new Vehicle(),new Amphibian(),"h1",47,11.1);
}
public static void main(String[] args) {
TwoTuple<String,Integer> ttsi = f();
System.out.println("ttsi = " + ttsi);
System.out.println("g() = " + g());
System.out.println("h() = " + h());
System.out.println("k() = " + k());
}
}
class Amphibian{}
class Vehicle{}
//Outputs
ttsi = (hi, 47)
g() = (com.daidaijie.generices.tuple.Amphibian@1540e19d, h1, 47)
h() = (com.daidaijie.generices.tuple.Vehicle@677327b6, com.daidaijie.generices.tuple.Amphibian@14ae5a5, h1, 47)
k() = (com.daidaijie.generices.tuple.Vehicle@7f31245a, com.daidaijie.generices.tuple.Amphibian@6d6f6e28, h1, 47, 11.1)
由于有了泛型，所以可以很容易的创建元组并令其返回一组任意类型的对象。
虽然如此，但是编写任意多类型的元组仍需要创建许多泛型类，这里需要根据情况来分析。
