场景：当在一个方法中， 你需要返回几个对象，这几个对象的类型一致，你可以返回一个数组；如果几个对象的类型不同呢，当然你可以返回一个Object[]数组，可是这样在使用结果数组的时候，就需要强转对象的类型，会导致类型不安全；也可以定义一个dto，当多个场景下需要使用的不同，需要定义多个dto，这样会类爆炸，而且重用率极低；在非常接近Java语言的Scala里有元组的定义：val t = (1, 3.14, "Fred")，就是一个不同类型的数据放到一个线性集合里，在Java里我们可以模拟出一个类似的结构，以适合上面的场景

demo：

1. abstract class Tuple {
3. public static void main (String[] args) {
4. Tuple tuple2 = Tuple.<String, Integer>of( "hello" , 1 );
5. Tuple tuple3 = Tuple.<String, Integer, String>of( "hello" , 1 , "hi" );
6. System.out.println(tuple2._1().get() + "|" + tuple2._2().get());
7. System.out.println(tuple3._1().get() + "|" + tuple3._2().get() + "|" + tuple3._3().get());
9. }
11. public static <E, T> Tuple of (E e, T t) {
12. return new Tuple2(e, t);
13. }
15. public static <E, T, K> Tuple of (E e, T t, K k) {
16. return new Tuple3(e, t, k);
17. }
19. public abstract <E> Optional<E> _1 ();
21. public abstract <E> Optional<E> _2 ();
23. public abstract <E> Optional<E> _3 ();
25. }
27. class Tuple2<E, T> extends Tuple {
28. private E e;
29. private T t;
31. Tuple2 (E e, T t) {
32. this .e = e;
33. this .t = t;
34. }
36. @Override
37. public Optional<E> _1 () {
38. return Optional.of(e);
39. }
41. @Override
42. public Optional<T> _2 () {
43. return Optional.of(t);
44. }
46. @Override
47. public <E> Optional<E> _3() {
48. return Optional.absent();
49. }
50. }
52. class Tuple3<E, T, K> extends Tuple {
53. private E e;
54. private T t;
55. private K k;
57. Tuple3 (E e, T t, K k) {
58. this .e = e;
59. this .t = t;
60. this .k = k;
61. }
63. public Optional<E> _1 () {
64. return Optional.of(e);
65. }
67. public Optional<T> _2 () {
68. return Optional.of(t);
69. }
71. public Optional<K> _3 () {
72. return Optional.of(k);
73. }
74. }

上面的代码中定义了三个类，父类为抽象类Tuple，此父类就是定义了一些模板方法，方法名有点不像Java方法名的命名规范，那是模仿scala里的方法命名，Tuple类没有其他作用，只是提供静态方法，创建Tuple的之类充当容器，提供多个容器的入口；

Tuple2<E,T>可以充当两个对象的容器，该容器内保持两个对象的引用，通过方法_1(), _2()获取第一个和第二个对象的值，在此并没有直接返回对象，而是返回一个Optional对象，这是提醒使用返回值的方法做非Null检查；

Tuple3<E,T,K>原理类似Tuple2，类似的可以做针对4个以及更多的对象容器，作为方法返回参数类型