元组的Java模式匹配

我有一个向量，其中每个对象都是一个元组，包含ex:的类型。现在我有了一大组元组，我如何才能找到这些元组中的所有模式，我不知道它们的起点和终点，以及有多少这样的模式
需要找到所有不同的模式以及它们出现的次数

例如：

现在我需要将前三个元组与最后一个元组进行匹配，因为它们是相同的。
如何在Java中进行匹配

---

我的输入只是一个对象的向量，其中每个对象都有一个类的上述字段，我不给出搜索模式，它应该识别向量中的所有不同模式。

我将执行以下操作：

• 首先，使用正则表达式生成实际字符串，表示一个元组<代码>（]+>）
• 创建一个Tuppel类，该类在构造函数中接受该类，根据需要实现equals和hashcode方法，并在迭代时将所有结果添加到集合中

类别：

Class MyTupel{
  private int a;
  private int b;
  private int c;
  private double d;

  public MyTupel(String tupel){
    //Regex to match a,b,c,d over here: ^<(\d+),(\d+),(\d+),([^>]+)>$
  }

  public boolean equals(MyTupel another){
    return (a == another.getA() && b == another.getB() && c = another.getC() && d == another.getD())
  }

  @Override
  public int hashCode(){
     return a+b+c+ (int)Math.floor(d);
  }

  //getter and setter
}

类MyTupel{
私人INTA；
私人INTB；
私人INTC；
私人双d；
公共MyTupel（字符串tupel）{
//正则表达式与此处的a、b、c、d匹配：^]+）>$
}
公共布尔等于（MyTupel另一个）{
返回（a==另一个.getA（）&&b==另一个.getB（）&&c=另一个.getC（）&&d==另一个.getD（））
}
@凌驾
公共int hashCode（）{
返回a+b+c+（整数）数学楼层（d）；
}
//接二连三
}

最后，你可以像（口头）一样使用它：

• 创建MyTuppel（或集合）的列表
• foreach匹配字符串“…”
• 创建Tuppel实例（

  Tuppel t=newtuppel（match）

  ）
• 若列表不包含元组：添加元组

---

考虑咆哮类

class Tuple<A,B,C,D>{

  public Tuple(A a,B b,C c, D d){
 ...
  }

@Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((a == null) ? 0 : a.hashCode());
        result = prime * result + ((b == null) ? 0 : b.hashCode());
        result = prime * result + ((c == null) ? 0 : c.hashCode());
        result = prime * result + ((d == null) ? 0 : d.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Tuple other = (Tuple) obj;
        if (a == null) {
            if (other.a != null)
                return false;
        } else if (!a.equals(other.a))
            return false;
        if (b == null) {
            if (other.b != null)
                return false;
        } else if (!b.equals(other.b))
            return false;
        if (c == null) {
            if (other.c != null)
                return false;
        } else if (!c.equals(other.c))
            return false;
        if (d == null) {
            if (other.d != null)
                return false;
        } else if (!d.equals(other.d))
            return false;
        return true;
 }
}

类元组{
公共元组（A、B、C、D）{
...
}
@凌驾
公共int hashCode（）{
最终整数素数=31；
int结果=1；
result=prime*result+（（a==null）？0:a.hashCode（）；
result=prime*result+（（b==null）？0:b.hashCode（）；
result=prime*result+（（c==null）？0:c.hashCode（）；
result=prime*result+（（d==null）？0:d.hashCode（）；
返回结果；
}
@凌驾
公共布尔等于（对象obj）{
if（this==obj）
返回true；
if（obj==null）
返回false；
如果（getClass（）！=obj.getClass（））
返回false；
元组其他=（元组）对象；
如果（a==null）{
if（other.a！=null）
返回false；
}如果（！a.equals（other.a））
返回false；
如果（b==null）{
if（other.b！=null）
返回false；
}else如果（！b.equals（other.b））
返回false；
如果（c==null）{
if（other.c！=null）
返回false；
}如果（！c.equals（other.c））
返回false；
如果（d==null）{
if（其他.d！=null）
返回false；
}else如果（！d.equals（other.d））
返回false；
返回true；
}
}

equals

方法未覆盖原始的

equals

method@user902383你是对的。因为我使用了

MyTuppel

作为参数，所以它足以创建一个polimorphism@如果我使用

对象

，则需要重写。但是我需要执行类检查等等。@user902383 Bean counter:）它不应该是复制/粘贴解决方案。如何识别前三个和后三个是相同的？？您可以简单地检查

list.contains（tuppel）

-如果您已经添加了它，这将返回true。（自定义相等功能将忽略它们是不同的对象。当它们的值相等时，它们将被渲染为相等）