java中的可变四维元组

是否有针对可变四维元组的Java实现

MutableTuple4<Intger, Integer, Double, Double> a;
a.setFirst(a.getFirst() + 1);

mutabletuple4a；
a、 setFirst（a.getFirst（）+1）；

有，但它专门用于向量数学，尤其是Java3D：

不适用于一般用途的tupling。它不允许你混合整数和双精度，就像你的例子所示

---

正如JB Nizet在评论中所说，类通常更合适。

有，但它专门用于向量数学，尤其是Java3D：

不适用于一般用途的tupling。它不允许你混合整数和双精度，就像你的例子所示

---

正如JB Nizet在评论中所说，类通常更合适。

有，但它专门用于向量数学，尤其是Java3D：

不适用于一般用途的tupling。它不允许你混合整数和双精度，就像你的例子所示

---

正如JB Nizet在评论中所说，类通常更合适。

有，但它专门用于向量数学，尤其是Java3D：

不适用于一般用途的tupling。它不允许你混合整数和双精度，就像你的例子所示

---

正如JB Nizet在评论中所说，类通常更合适。

没有内置的通用Tuple4类，但是您可以轻松地编写自己的通用任意长度的Tuple类，并且有许多实现可用于代码基础，例如（）

还有一个库，它提供了不可变元组，长度可达10个元素，您可以基于这些元素来实现（尽管我个人没有使用过它）。也许你可以问问自己是否需要可变性

事实上，正如其他人已经提到的，我强烈质疑具有任意值类型的可变对象的有效性——通常在类中封装特定的概念比传递“值包”要好

除此之外，这里有一个示例实现，它基于上面提到的ApacheMutableTriple类，可以构建在这个类的基础上。与往常一样，在多线程环境中，您需要非常谨慎地使用可变变量：不要以任何方式考虑此代码THealSead（我通常倾向于在任何可能的情况下都是不可变的）。

公共类MutableTuple4{
私有静态最终长serialVersionUID=1L；
公众优先；
公共B秒；
公共C第三；
第四次公开辩论；
公共可变元组4（aa，bb，cc，dd）{
第一个=a；
这个秒=b；
这三分之一=c；
这四分之一=d；
} 
公共A getFirst（）{
先把这个还给我；
}
公共空间优先（A优先）{
this.first=first；
}
//剩下的接球手和二传手。。。
//等等。。。
@凌驾
公共int hashCode（）{
int hash=3；
hash=23*hash+Objects.hashCode（this.first）；
hash=23*hash+Objects.hashCode（this.second）；
hash=23*hash+Objects.hashCode（这是第三个）；
hash=23*hash+Objects.hashCode（这是第四个）；
返回散列；
}
@凌驾
公共布尔等于（对象obj）{
if（obj==null）{
返回false；
}
如果（getClass（）！=obj.getClass（））{
返回false；
}
最终元组other=（元组）obj；
如果（！Objects.equals（this.first，other.first））{
返回false；
}
如果（！Objects.equals（this.second，other.second））{
返回false；
}
如果（！Objects.equals（this.third，other.third））{
返回false；
}
如果（！Objects.equals（this.fourth，other.fourth））{
返回false；
}
返回true；
} 
}

没有内置的通用Tuple4类，但您可以轻松编写自己的通用任意长度的Tuple类，并且有许多实现可用于代码基础，例如（）

还有一个库，它提供了不可变元组，长度可达10个元素，您可以基于这些元素来实现（尽管我个人没有使用过它）。也许你可以问问自己是否需要可变性

事实上，正如其他人已经提到的，我强烈质疑具有任意值类型的可变对象的有效性——通常在类中封装特定的概念比传递“值包”要好

除此之外，这里有一个示例实现，它基于上面提到的ApacheMutableTriple类，可以构建在这个类的基础上。与往常一样，在多线程环境中，您需要非常谨慎地使用可变变量：不要以任何方式考虑此代码THealSead（我通常倾向于在任何可能的情况下都是不可变的）。

公共类MutableTuple4{
私有静态最终长serialVersionUID=1L；
公众优先；
公共B秒；
公共C第三；
第四次公开辩论；
公共可变元组4（aa，bb，cc，dd）{
第一个=a；
这个秒=b；
这三分之一=c；
这四分之一=d；
} 
公共A getFirst（）{
先把这个还给我；
}
公共空间优先（A优先）{
this.first=first；
}
//剩下的接球手和二传手。。。
//等等。。。
@凌驾
公共int hashCode（）{
int hash=3；
hash=23*hash+Objects.hashCode（this.first）；
hash=23*hash+Objects.hashCode（this.second）；
hash=23*hash+Objects.hashCode（这是第三个）；
hash=23*hash+Objects.hashCode（这是第四个）；
返回散列；
}
@凌驾
公共布尔等于（对象obj）{
if（obj==null）{
返回false；
}
如果（getClass（）！=obj.getClass（））{
public class MutableTuple4<A, B, C, D> { 

    private static final long serialVersionUID = 1L;

    public A first; 
    public B second; 
    public C third; 
    public D fourth; 

    public MutableTuple4(A a, B b, C c, D d) { 
        this.first = a; 
        this.second = b; 
        this.third = c;
        this.fourth = d;
    } 

    public A getFirst() {
        return this.first;
    }

    public void setFirst(A first) {
        this.first = first;
    }

    // remaining getters and setters here...
    // etc...

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 23 * hash + Objects.hashCode(this.first);
        hash = 23 * hash + Objects.hashCode(this.second);
        hash = 23 * hash + Objects.hashCode(this.third);
        hash = 23 * hash + Objects.hashCode(this.fourth);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Tuple<A, B, C, D> other = (Tuple<A, B, C, D>) obj;
        if (!Objects.equals(this.first, other.first)) {
            return false;
        }
        if (!Objects.equals(this.second, other.second)) {
            return false;
        }
        if (!Objects.equals(this.third, other.third)) {
            return false;
        }
        if (!Objects.equals(this.fourth, other.fourth)) {
            return false;
        }
        return true;    
    } 

}