Java元组Tuple介绍与使用

朱雀 2022-10-01 06:45 190阅读 0赞

一、元组介绍 仅仅一次方法调用就可以返回多个对象,你应该经常需要这样的功能吧.可以return语句只允许返回单个对(可能有人说返回一个集合就可以了,请记住,一个集合也只是一个对象而已)因此,解决办法就是创建一个对象,用它来持有想要返回的对象.当然,可以在每次需要的时候,专门创建一个类来完成这样的工作.可是有了泛型,我们就能够一次性的解决问题,以后再也不用再这种问题上浪费时间了.同时,我们再编译器就可以确保类型安全.

上述概念称为元组(tuple),它是将一组对象直接打包存储与其中的一个单一对象.这个容器对象允许读取其中的元素.但是不允许向其中存放新的对象.(这个概念也称为数据传送对象,或信使)

通常元素具有任意长度,同时,元组中的对象可以是任何不同的类型.不过,我们希望能够为每一个对象指明其类型,并且从容器中读取出来时,能够得到正确的类型.要处理不同长度的问题,我们需要创建不同的元组.采用下面的编码形式无疑是更安全的做法,这样的话,如果程序员想要使用具有不同元素的元组,就强制要求他们创建一个新的元组对象.并且可以利用继承机制实现长度更长的元组.

元组和列表list一样，都可能用于数据存储，包含多个数据；但是和列表不同的是：列表只能存储相同的数据类型，而元组不一样，它可以存储不同的数据类型，比如同时存储int、string、list等，并且可以根据需求无限扩展。比如说在web应用中，经常会遇到一个问题就是数据分页问题，查询分页需要包含几点信息：当前页数、页大小；查询结果返回数据为：当前页的数据记录，但是如果需要在前台显示当前页、页大小、总页数等信息的时候，就必须有另外一个信息就是：数据记录总数，然后根据上面的信息进行计算得到总页数等信息。这个时候查询某一页信息的时候需要返回两个数据类型，一个是list（当前也的数据记录），一个是int（记录总数）。当然，完全可以在两个方法、两次数据库连接中得到这两个值。事实上在查询list的时候，已经通过sql查询得到总计录数，如果再开一个方法，再做一次数据库连接来查询总计录数，不免有点多此一举、浪费时间、浪费代码、浪费生命。言重了~在这种情况下，我们就可以利用二元组，在一次数据库连接中，得到总计录数、当前页记录，并存储到其中，简单明了！([www.cnblogs.com/davidwang45…][www.cnblogs.com_davidwang45])

二、使用介绍 二元组常见代码形式可以如下所示:

public class TwoTuple<A, B> \{

public final A first;
    
    public final B second;
    
    public TwoTuple(A a, B b){
        first = a;
        second = b;
    }
    
    public String toString(){
        return "(" + first + ", " + second + ")";
    }
    复制代码

\} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 利用继承机制实现长度更长的元组.将上述二元组扩展为三元组代码形式可以如下所示: 1 public class ThreeTuple<A, B, C> extends TwoTuple<A, B>\{

public final C third;
    
    public ThreeTuple(A a, B b, C c) {
        super(a, b);
        third = c;
    }
    
    public String toString(){
        return "(" + first + "," + second + "," + third + ")";
    }
    复制代码

\} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 利用继承机制实现长度更长的元组.将上述三元组扩展为四元组代码形式可以如下所示: 1 public class FourTuple<A, B, C, D> extends ThreeTuple<A,B,C>\{

public final D fourth;
    
    public FourTuple(A a, B b, C c, D d) {
        super(a, b, c);
        fourth = d;
    }
    
    public String toString(){
        return "(" + first + "," + second + "," + third + "," + fourth + ")";
    }
    复制代码

\} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 为了使用元组,你只需定义一个长度适合的元组,将其作为方法的返回值,然后在return语句中创建该元组,并返回即可.例如下面使用方式:

使用方式实例一:

/\*\*

*  由于有了泛型,你可以很容易的创建元组,令其返回一组任意类型的对象,而你所要做的,只是编写表达式而已. \*/ public class TupleTest \{
    
    static TwoTuple<String, Integer> f()\{ //Autoboxing conveerts the int to Integer; return new TwoTuple<String, Integer>("hi", 47); \}
    
    static ThreeTuple<Amphibian, String, Integer> g()\{ return new ThreeTuple<Amphibian, String, Integer>(new Amphibian(), "hi", 47); \}
    
    static FourTuple<Vehicle, Amphibian, String ,Integer> h()\{ return new FourTuple<Vehicle, Amphibian, String, Integer>(new Vehicle(), new Amphibian(), "hi", 47); \}
    
    public static void main(String\[\] args) \{ TwoTuple<String, Integer> ttsi = f(); System.out.println(ttsi); System.out.println(g()); System.out.println(h()); \}

class Amphibian \{\}

class Vehicle \{\} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 使用方式实例二:

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.HashMap; import java.util.Map;

public class DynamicProxyMixin \{

public static void main(String[] args) {
        Object mixin = MixinProxy.newInstance(new TwoTuple(new BasicImpl(), Basic.class), new TwoTuple(new TimeStampedImp(), TimeStamped.class), new TwoTuple(new SerialNumberedImpl(), SerialNumbered.class));
        Basic b = (Basic) mixin;
        TimeStamped t = (TimeStamped) mixin;
        SerialNumbered s = (SerialNumbered) mixin;
        b.set("hello");
        System.out.println(b.get());
        System.out.println(t.getStamp());
        System.out.println(s.getSerialNumber());
    }
    复制代码

class MixinProxy implements InvocationHandler\{

Map<String, Object> delegatesByMethod;
    
    public MixinProxy(TwoTuple<Object, Class<?>>... pairs){
        delegatesByMethod = new HashMap<String, Object>();
        for(TwoTuple<Object, Class<?>> pair : pairs){
            for(Method method : pair.second.getMethods()){
                String methodName = method.getName();
                if(!delegatesByMethod.containsKey(methodName)){
                    delegatesByMethod.put(methodName, pair.first);
                }
            }
        }
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        Object delegate = delegatesByMethod.get(methodName);
        return method.invoke(delegate, args);
    }
    
    public static Object newInstance(TwoTuple... pairs){
        Class[] interfaces = new Class[pairs.length];
        for(int i = 0; i < pairs.length; i++){
            interfaces[i] = (Class) pairs[i].second;
        }
        ClassLoader cl = pairs[0].first.getClass().getClassLoader();
        return Proxy.newProxyInstance(cl, interfaces, new MixinProxy(pairs));
    }
    复制代码

interface TimeStamped\{ long getStamp(); \}

class TimeStampedImp implements TimeStamped\{

private final long timeStamp;
    
    public TimeStampedImp() {
        timeStamp = new Date().getTime();
    }
    
    @Override
    public long getStamp() {
        return timeStamp;
    }
    复制代码

interface SerialNumbered\{ long getSerialNumber(); \}

class SerialNumberedImpl implements SerialNumbered\{

private static long counter = 1;
    
    private final long serialNumber = counter++;
    
    public long getSerialNumber(){
        return serialNumber;
    }
    复制代码

interface Basic\{ public void set(String val);

public String get();
    复制代码

class BasicImpl implements Basic\{ private String value;

public void set(String val){
        value = val;
    }
    
    @Override
    public String get() {
        return value;
    }
    复制代码

## \} ##

转载于:https://juejin.im/post/5c00afccf265da6142739ff1

[www.cnblogs.com_davidwang45]: https://link.juejin.im?target=http%3A%2F%2Fwww.cnblogs.com%2Fdavidwang456%2Fp%2F4514659.html
[blog.csdn.net_u013412772]: https://link.juejin.im?target=https%3A%2F%2Fblog.csdn.net%2Fu013412772%2Farticle%2Fdetails%2F74298257