Java-使对象集合友好

如果一个对象拥有一个唯一的主键，那么它需要实现什么样的接口才能对集合友好，特别是在高效排序、哈希等方面

如果主键是一个字符串，那么如何最好地实现这些接口

谢谢

必须实现和（在实现接口之后）

在每种情况下，因为您有一个主键的字符串，所以您可以考虑简单地将这些调用发送到字符串。例如：

public class Friendly implements Comparable<Friendly>
{
    // presumably you've got other fields as well
    private String primaryKey;
    public Friendly(String primaryKey)
    {
        this.primaryKey = primaryKey;
    }

    public int compareTo(Friendly other)
    {
        return primaryKey.compareTo(other.primaryKey);
    }

    public int hashCode()
    {
        return primaryKey.hashCode();
    }

    public boolean equals(Object o)
    {
        return (o instanceof Friendly) && primaryKey.equals(((Friendly)o).primaryKey);
    }
}

公共类友好的实现
{
//大概你还有其他领域
私有字符串主密钥；
公众友好型（字符串primaryKey）
{
this.primaryKey=primaryKey；
}
公共int比较（友好的其他）
{
返回primaryKey.compareTo（其他primaryKey）；
}
公共int hashCode（）
{
返回primaryKey.hashCode（）；
}
公共布尔等于（对象o）
{
返回（友好的o实例）和&primaryKey.equals（（（友好的）o.primaryKey）；
}
}

字符串已经非常适合进行散列和比较，因此，如果字符串能够真正唯一地识别对象，那么您的状态良好。只需确保实现排序和覆盖

equals

和

hashCode

的

Comparable

接口（委托主键字符串）如果主键是

对象

，则需要确定排序顺序是基于

对象

还是基于

对象

的主键

对象

在任何一种情况下，要排序的项目都应该使用适当的

compareTo（）

方法实现

Comparable

接口。可能性很大，这意味着您也必须重写

equals（）

和

hashCode（）

，因为只有一些主键对象可能具有正确的默认实现

---

如果您想基于一些非自然排序顺序进行排序，那么还需要实现一些“额外的”

比较器。有序的
集合
支持可选的
比较器
您必须重写
对象.equals（）
和
对象.hashCode（）
，并实现
可比较的
接口。这将使您的类在执行任何类型的排序或散列时完全“兼容”，包括使用
Collections.sort（
）、任何
Map
类或任何
Set
类。如果该类很有可能被放入某种集合中，那么它肯定会实现这三种方法

public class A implements Comparable<A>{
    private String key;

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

        A that = (A)obj;
        return this.key.equals(that.key);    
    }

    @Override
    public int hashCode(){
        return key.hashCode();
    }

    @Override
    public int compareTo(A that){
        //returns -1 if "this" object is less than "that" object
        //returns 0 if they are equal
        //returns 1 if "this" object is greater than "that" object
        return this.key.compareTo(that.key);
    }
}

公共类A实现了可比性{
私钥；
@凌驾
公共布尔等于（对象obj）{
如果（this==obj）返回true；
如果（！（obj instanceof A））返回false；
A该=（A）obj；
返回this.key.equals（that.key）；
}
@凌驾
公共int hashCode（）{
return key.hashCode（）；
}
@凌驾
公共整数比较（A）{
//如果“this”对象小于“that”对象，则返回-1
//如果它们相等，则返回0
//如果“this”对象大于“that”对象，则返回1
返回this.key.compareTo（that.key）；
}
}

请记住，如果两个对象相等，则：

它们的散列码也必须相等且相同
compareTo（）
必须返回0
并确保compareTo符合“平等”合同。