【问题标题】:implement comparable interface for bidirectional flows为双向流实现可比较的接口
【发布时间】:2010-08-17 09:34:17
【问题描述】:

这段代码应该将双向流视为一个流。 例如:

srcAddr,dstAddr,srcPort,dstPort
192.168.1.65, 217.174.16.1, 123456,80

应该和

一样
217.174.16.1, 192.168.1.65,80,123456

另一个例子:

192.168.1.65, 217.174.16.1, 12345, 80, TCP
217.174.16.1, 192.168.1.65, 80, 12345, TCP
192.168.1.65, 217.174.16.1, 12345, 80, TCP
217.174.16.1, 192.168.1.65, 80, 12345, TCP

我想保持这样:

Flow 1: key---> value (keeps statistics about each packet, like length and timeArrival)

[192.168.1.65, 217.174.16.1, 12345, 80] ----> [(outgoing, 1,2)(incoming,3,4)()()...]

192.168.1.65, 69.100.70.80, 98521, 80 69.100.70.80, 192.168.1.65, 80, 98521 192.168.1.65, 69.100.70.80, 98521, 80 69.100.70.80, 192.168.1.65, 80, 98521 192.168.1.65, 69.100.70.80, 98521, 80 69.100.70.80, 192.168.1.65, 80, 98521

Flow 2: [192.168.1.65, 69.100.70.80, 98521, 80] --> [(outgoing, 1,2)(incoming,3,4)()()...]

我应该如何改变它以获得结果? [我使用 hashMap,这类 Flows 是我的关键]

 package myclassifier;
 public class Flows implements Comparable<Flows> {

String srcAddr = "", dstAddr = "", protocol = "";
int srcPort = 0, dstPort = 0;

public Flows(String sIP, String dIP, int sPort, int dPort){
    this.srcAddr = sIP;
    this.dstAddr = dIP;
    this.srcPort = sPort;
    this.dstPort = dPort;
    //this.protocol = protocol;

}
public Flows(){

}

public int compareTo(Flows other) {
    int res = 1;
    if(this.equals(other)){
        return res=0;
    }else
        return 1;
}



 @Override
public int hashCode() {

    final int prime = 31;
    int result = 1;
    result = prime * result + ((dstAddr == null) ? 0 : dstAddr.hashCode());
    result = prime * result + dstPort;
    result = prime * result + ((srcAddr == null) ? 0 : srcAddr.hashCode());
    result = prime * result + srcPort;
    return result;

}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;

    if (getClass() != obj.getClass())
        return false;

    Flows other = (Flows) obj;

    if (dstAddr == null) {
        if (other.dstAddr != null)
            return false;
    } else if (!dstAddr.equals(other.dstAddr))
        return false;
    if (dstPort != other.dstPort)
        return false;
    if (srcAddr == null) {
        if (other.srcAddr != null)
            return false;
    } else if (!srcAddr.equals(other.srcAddr))
        return false;
    if (srcPort != other.srcPort)
        return false;
    return true;

}

 @Override
public String toString() {
return String.format("[%s, %s, %s, %s, %s]", srcAddr, dstAddr, srcPort, dstPort, protocol);
}


}

【问题讨论】:

  • 你之前得到的所有提示发生了什么?我记得斯蒂芬 C 对如何编写单向比较器有一个很好的答案。那个代码怎么了?你怎么又回到了return 1;,其他人都指出它违反了合同?
  • 不,我没有得到答案。因为我没有使用 compareTo 方法来比较大小。这就是为什么我仍然遇到问题。

标签: java network-programming overriding compare comparable


【解决方案1】:

可能最简洁的方法是定义这些方法:

  • Flows reverse() 返回给定 Flows 的相反方向 Flows
  • Flows canon() 返回 Flows 的规范化形式
    • 您可以定义例如如果srcAddr.compareTo(dstAddr) &lt;= 0,则Flows 是佳能
    • 否则,它的reverse() 定义为佳能

那么对于非定向比较,你可以简单地比较两个流的规范形式。有了这些方法,其余的逻辑就变得非常清晰易读(参见下面的代码)。


开启Comparator、Comparable,并与equals保持一致

使用上面的reverse() 概念,如果您总是想要f.equals(f.reverse()),那么也许首先不应该有任何方向性的概念。如果是这种情况,那么规范化是最好的方法。

如果f 通常不是equals(f.reverse()),但您可能希望f 和f.reverse() 与0 进行比较,则不应使用Comparable,因为这样做会强制执行自然排序,即与equals不一致。

来自文档:

类C 的自然排序被称为与 equals 一致当且仅当e1.compareTo(e2) == 0 具有与e1.equals(e2) 相同的布尔值对于每个e1 和e2 类 C。

强烈建议(虽然不是必需的)自然排序与equals 保持一致。

也就是说,您不应在Comparable 中强加与equals 不一致的自然排序,而应改为提供无方向的Comparator。

以此类推,将这种情况与String 进行比较,Comparator&lt;String&gt; CASE_INSENSITIVE_ORDER 允许两个不是equals 的字符串在不区分大小写的情况下与 0 进行比较。

所以在这里你要写一个Comparator&lt;Flows&gt;,它允许两个不是equals的Flows通过方向不敏感与0进行比较。

另见

相关问题


示例实现

这是一个 Edge 类的示例实现,它具有 from 和 to,具有与 equals 一致的定向自然排序,它还提供了一个非定向 Comparator。

然后用3种Set进行测试:

  • 一个HashSet,用于测试equals和hashCode
  • TreeSet,用于测试自然排序
  • 带有自定义Comparator 的TreeSet,用于测试无方向性

实现简洁明了,应该具有指导意义。

import java.util.*;

class Edge implements Comparable<Edge> {
    final String from, to;
        
    public Edge(String from, String to) {
        this.from = from;
        this.to = to;
    }
    @Override public String toString() {
        return String.format("%s->%s", from, to);
    }
    public Edge reverse() {
        return new Edge(to, from);
    }
    public Edge canon() {
        return (from.compareTo(to) <= 0) ? this : this.reverse();
    }
    @Override public int hashCode() {
        return Arrays.hashCode(new Object[] {
            from, to
        });
    }   
    @Override public boolean equals(Object o) {
        return (o instanceof Edge) && (this.compareTo((Edge) o) == 0);
    }
    @Override public int compareTo(Edge other) {
        int v;

        v = from.compareTo(other.from);
        if (v != 0) return v;

        v = to.compareTo(other.to);
        if (v != 0) return v;

        return 0;
    }
    public static Comparator<Edge> NON_DIRECTIONAL =
        new Comparator<Edge>() {
            @Override public int compare(Edge e1, Edge e2) {
                return e1.canon().compareTo(e2.canon());
            }
        };
}

public class Main {
    public static void main(String[] args) {
        testWith(new HashSet<Edge>());
        testWith(new TreeSet<Edge>());
        testWith(new TreeSet<Edge>(Edge.NON_DIRECTIONAL));
    }
    public static void testWith(Set<Edge> set) {
        set.clear();
        set.add(new Edge("A", "B"));
        set.add(new Edge("C", "D"));
        System.out.println(set.contains(new Edge("A", "B")));
        System.out.println(set.contains(new Edge("B", "A")));
        System.out.println(set.contains(new Edge("X", "Y")));
        System.out.println(set);
        set.add(new Edge("B", "A"));
        set.add(new Edge("Z", "A"));
        System.out.println(set);
        System.out.println();
    }
}

输出如下(as seen on ideone.com),注释:

// HashSet
// add(A->B), add(C->D)
true    // has A->B?
false   // has B->A?
false   // has X->Y?
[C->D, A->B]
// add(B->A), add(Z->A)
[B->A, C->D, Z->A, A->B]

// TreeSet, natural ordering (directional)    
// add(A->B), add(C->D)
true    // has A->B?
false   // has B->A?
false   // has X->Y
[A->B, C->D]
// add(B->A), add(Z->A)
[A->B, B->A, C->D, Z->A]

// TreeSet, custom comparator (non-directional)
// add(A->B), add(C->D)
true    // has A->B?
true    // has B->A?
false   // has X->Y?
[A->B, C->D]
// add(B->A), add(Z->A)
[A->B, Z->A, C->D]

请注意,在非定向 TreeSet 中,Z-&gt;A 被规范化为 A-&gt;Z,这就是它按此顺序出现在 C-&gt;D 之前的原因。同样,B-&gt;A 被规范化为 A-&gt;B,这已经在集合中,这就解释了为什么那里只有 3 个Edge。

要点

  • Edge 是不可变的
  • Arrays.hashCode(Object[]) 用于方便;无需编写所有公式
  • 如果自然排序与equals一致,可以在equals中使用compareTo == 0
  • 为了简洁明了,使用compareTo 中的多步return 逻辑
  • 拥有reverse() 和canon() 大大简化了非定向比较
    • 简单地比较它们的自然顺序中的规范化形式

另见

  • 有效的 Java 第 2 版
    • 第 8 项:覆盖equals 时遵守总合同
    • 第 9 项:当您覆盖 equals 时,请始终覆盖 hashCode
    • 第 10 项:始终覆盖 toString
    • 第 12 项:考虑实施Comparable
    • 第 15 条:最小化可变性
    • 第36条:始终使用@Override注解
    • 第 47 项:了解和使用库

【讨论】:

  • 我不需要逆向流动。我需要的是保存记录,双向流被视为一个记录。
  • @Red Lion - 你确实需要考虑反向流动,这完全是你的问题所在。再次阅读你自己问题的前几行;反转流的方向是正是你在那里描述的。
  • @Red Lion:很多非常聪明的人已经多次尝试帮助您,但您似乎仍然遇到问题。我建议您绝对清楚您要做什么,这样我们就可以有效地帮助您,而不是一遍又一遍地重复相同的信息,这些信息显然以某种方式对您毫无用处。
  • @Andrzej:在第一行我说:“这段代码应该将双向流视为一个流”。然后提供了两个例子来说明我所说的两个流程的意思。我正在获取包含这些信息的数据包,所以我需要确定它们是否属于流。
  • @Poly:是的,你是对的。我用不同的话重复我的问题以使其更清楚,因为这些解释都不适用于我的案例。他们都很好,但不完全是我想要的。
【解决方案2】:

关键是正确实现equals方法。在您的 equals 方法中,当目标地址不匹配时,您将返回 false。这是您需要添加额外逻辑来检查相等性的地方,因为您希望具有双向相等性。相等性的第一遍应该是检查源、目的地、端口的相等性。第二遍应该是源和目标的反向相等。您还需要对默认值进行特殊规定,例如在您的示例中,排除 portno(80) 默认为 true。

【讨论】:

    【解决方案3】:

    我不知道这是否对你有帮助。但正如你所说,它在两个方向都有效

    import java.util.HashSet;
     public class Flows implements Comparable<Flows> {
    
    String srcAddr = "", dstAddr = "", protocol = "";
    int srcPort = 0, dstPort = 0;
    
    public Flows(String sIP, String dIP, int sPort, int dPort){
        this.srcAddr = sIP;
        this.dstAddr = dIP;
        this.srcPort = sPort;
        this.dstPort = dPort;
        //this.protocol = protocol;
    
    }
    public Flows(){
    
    }
    
    public int compareTo(Flows other) {
    
        if(this.equals(other)){
            return 0;
        }else
            return 1;
    }
    
    
    
     @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((dstAddr == null) ? 0 : dstAddr.hashCode())+((srcAddr == null) ? 0 : srcAddr.hashCode());
        result = prime * result + dstPort+srcPort;
        return result;
    
    }
    
    @Override
    public boolean equals(Object obj) {
       if (this == obj)
            return true;
    
       if(obj instanceof Flows)
       {
        Flows c=(Flows)obj;
        if(srcAddr.equals(c.dstAddr) && dstAddr.equals(c.srcAddr) &&srcPort==c.dstPort && dstPort==c.srcPort)
          return true;
    
        if(srcAddr.equals(c.srcAddr) && dstAddr.equals(c.dstAddr) && srcPort==c.srcPort && dstPort==c.dstPort)
            return true;
       }
        return false;
    
    }
    
     @Override
    public String toString() {
    return String.format("[%s, %s, %s, %s, %s]", srcAddr, dstAddr, srcPort, dstPort, protocol);
    }
    
    public static void main(String[] args) {
        Flows f1=new Flows("192.168.1.65","217.174.16.1", 123456,80);
        Flows f2=new Flows("217.174.16.1","192.168.1.65",80,123456);
    
        Flows f3=new Flows("192.168.1.66","217.174.16.1", 123456,80);
        Flows f4=new Flows("217.174.16.1","192.168.1.66",80, 123456);
        System.out.println(f1.hashCode()+ " "+f2.hashCode());
        HashSet<Flows> hh=new HashSet<Flows>();
        hh.add(f1);
        hh.add(f2);
        hh.add(f3);
        hh.add(f4);
        System.out.println(f1.compareTo(f2));
        System.out.println(hh);
    }
    }
    

    我已经使用 hashset 进行了测试。所以它应该也适用于 hashmap。

    【讨论】:

    • 你的compareTo 坏了。如果f1.compareTo(f2) 返回一个正数,f2.compareTo(f1) 必须返回一个负数。见download.oracle.com/javase/6/docs/api/java/lang/…
    • 如何纠正这个问题?我只是按照问题给出的代码。
    • 实际上 f1 和 f2 都是相等的,因为 f2 是 f1 的反向流动,因此它们返回 0。至于返回 -1 和 +1,我不知道我应该考虑什么理由流对象大于或小于另一个。
    • @Poly:我的意思是,因为我并没有真正比较长度,所以我无法得到正值或负值。我需要比较两个数据包,我不介意源和目标的端口和地址是否被反转。我将用另一个例子更新我的问题。顺便说一句,感谢您的考虑,我真的很感激。
    • @Red:上面的代码对你有用吗。如果不是根据你的需要,告诉我,我会删除它。
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2016-05-08
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2020-12-02
    • 2012-11-01
    • 1970-01-01
    相关资源
    最近更新 更多