Java元组Tuple介绍与使用

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

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

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

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

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

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

public class TwoTuple {

  1. public final A first;
  2. public final B second;
  3. public TwoTuple(A a, B b){
  4. first = a;
  5. second = b;
  6. }
  7. public String toString(){
  8. return "(" + first + ", " + second + ")";
  9. }
  10. 复制代码

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

  1. public final C third;
  2. public ThreeTuple(A a, B b, C c) {
  3. super(a, b);
  4. third = c;
  5. }
  6. public String toString(){
  7. return "(" + first + "," + second + "," + third + ")";
  8. }
  9. 复制代码

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

  1. public final D fourth;
  2. public FourTuple(A a, B b, C c, D d) {
  3. super(a, b, c);
  4. fourth = d;
  5. }
  6. public String toString(){
  7. return "(" + first + "," + second + "," + third + "," + fourth + ")";
  8. }
  9. 复制代码

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

使用方式实例一:

/**

  • 由于有了泛型,你可以很容易的创建元组,令其返回一组任意类型的对象,而你所要做的,只是编写表达式而已. */ public class TupleTest {

    static TwoTuple f(){ //Autoboxing conveerts the int to Integer; return new TwoTuple(“hi”, 47); }

    static ThreeTuple g(){ return new ThreeTuple(new Amphibian(), “hi”, 47); }

    static FourTuple h(){ return new FourTuple(new Vehicle(), new Amphibian(), “hi”, 47); }

    public static void main(String[] args) { TwoTuple 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 {

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

}

class MixinProxy implements InvocationHandler{

  1. Map<String, Object> delegatesByMethod;
  2. public MixinProxy(TwoTuple<Object, Class<?>>... pairs){
  3. delegatesByMethod = new HashMap<String, Object>();
  4. for(TwoTuple<Object, Class<?>> pair : pairs){
  5. for(Method method : pair.second.getMethods()){
  6. String methodName = method.getName();
  7. if(!delegatesByMethod.containsKey(methodName)){
  8. delegatesByMethod.put(methodName, pair.first);
  9. }
  10. }
  11. }
  12. }
  13. @Override
  14. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  15. String methodName = method.getName();
  16. Object delegate = delegatesByMethod.get(methodName);
  17. return method.invoke(delegate, args);
  18. }
  19. public static Object newInstance(TwoTuple... pairs){
  20. Class[] interfaces = new Class[pairs.length];
  21. for(int i = 0; i < pairs.length; i++){
  22. interfaces[i] = (Class) pairs[i].second;
  23. }
  24. ClassLoader cl = pairs[0].first.getClass().getClassLoader();
  25. return Proxy.newProxyInstance(cl, interfaces, new MixinProxy(pairs));
  26. }
  27. 复制代码

}

interface TimeStamped{ long getStamp(); }

class TimeStampedImp implements TimeStamped{

  1. private final long timeStamp;
  2. public TimeStampedImp() {
  3. timeStamp = new Date().getTime();
  4. }
  5. @Override
  6. public long getStamp() {
  7. return timeStamp;
  8. }
  9. 复制代码

}

interface SerialNumbered{ long getSerialNumber(); }

class SerialNumberedImpl implements SerialNumbered{

  1. private static long counter = 1;
  2. private final long serialNumber = counter++;
  3. public long getSerialNumber(){
  4. return serialNumber;
  5. }
  6. 复制代码

}

interface Basic{ public void set(String val);

  1. public String get();
  2. 复制代码

}

class BasicImpl implements Basic{ private String value;

  1. public void set(String val){
  2. value = val;
  3. }
  4. @Override
  5. public String get() {
  6. return value;
  7. }
  8. 复制代码

}

作者:可乐丶 来源:CSDN 原文:blog.csdn.net/u013412772/… 版权声明:本文为博主原创文章,转载请附上博文链接!

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

发表评论

表情:
评论列表 (有 0 条评论,228人围观)

还没有评论,来说两句吧...

相关阅读

    相关 Python (Tuple)操作

    Python的元组与列表类似,不同之处在于元组的元素不能修改,元组使用小括号,列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可 一、创建元组 代码

    相关 Scala 的 Tuple

    元组的定义:与列表一样,与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。当定义的元组当中包含不同的数据类型,可看到返回值开始会包含其所对

    相关 JavaTuple

    元组和列表list一样,都可能用于数据存储,包含多个数据;但是和列表不同的是:列表只能存储相同的数据类型,而元组不一样,它可以存储不同的数据类型,比如同时存储int、strin

    相关 JavaTuple介绍使用

    一、元组介绍 仅仅一次方法调用就可以返回多个对象,你应该经常需要这样的功能吧.可以return语句只允许返回单个对(可能有人说返回一个集合就可以了,请记住,一个集合也只是一个对