scala学习-scala中的元组Tuple概念

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

abstract class Tuple {  

public static void main (String[] args) {  
        Tuple tuple2 = Tuple.<String, Integer>of("hello", 1);  
        Tuple tuple3 = Tuple.<String, Integer, String>of("hello", 1, "hi");  
        System.out.println(tuple2._1().get() + "|" + tuple2._2().get());  
        System.out.println(tuple3._1().get() + "|" + tuple3._2().get() + "|" + tuple3._3().get());  

    }  

public static  <E, T> Tuple of (E e, T t) {  
return new Tuple2(e, t);  
    }  

public static  <E, T, K> Tuple of (E e, T t, K k) {  
return new Tuple3(e, t, k);  
    }  

public abstract <E> Optional<E> _1 ();  

public abstract <E> Optional<E> _2 ();  

public abstract <E> Optional<E> _3 ();  

}  

class Tuple2<E, T> extends Tuple {  
private E e;  
private T t;  

    Tuple2 (E e, T t) {  
this.e = e;  
this.t = t;  
    }  

@Override  
public Optional<E> _1 () {  
return Optional.of(e);  
    }  

@Override  
public Optional<T> _2 () {  
return Optional.of(t);  
    }  

@Override  
public <E> Optional<E> _3() {  
return Optional.absent();  
    }  
}  

class Tuple3<E, T, K> extends Tuple {  
private E e;  
private T t;  
private K k;  

    Tuple3 (E e, T t, K k) {  
this.e = e;  
this.t = t;  
this.k = k;  
    }  

public Optional<E> _1 () {  
return Optional.of(e);  
    }  

public Optional<T> _2 () {  
return Optional.of(t);  
    }  

public Optional<K> _3 () {  
return Optional.of(k);  
    }  
}  

运行结果如下

hello|1
hello|1|hi

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