众所周知,通过==比较浮点数通常是一个错误.在我写的3D矢量类(具有浮点分量X,Y,Z)中,如果它们的距离被认为是零,则认为两个矢量相等.
public override bool Equals(object obj)
{
if (obj == null) {
return false;
}
if (GetType () != obj.GetType ()) {
return false;
}
float d = DistSq ((Vec) obj);
return IsConsideredZero (d);
}
public float DistSq(Vec p)
{
Vec d = this - p;
return d.LengthSq ();
}
public float LengthSq()
{
return X * X + Y * Y + Z * Z;
}
private const float VEC_COMPARE_EPSILON_ABS = 1E-05f;
public static bool IsConsideredZero(float f)
{
return …将对象添加到.NET System.Collections.Generic.Dictionary类时,密钥的哈希码将在内部存储并用于以后的比较.当哈希码在其初始插入字典后发生变化时,它经常变得"不可访问",并且当存在检查(即使使用相同的引用)返回false时,它可能会使其用户感到惊讶(下面的示例代码).
该GetHashCode的文件说:
为对象GetHashCode方法必须一致,只要没有修改确定的该对象的Equals方法返回值的对象的状态返回相同的散列码.
因此,根据GetHashCode文档,只要更改了相等的确定状态,哈希码就会改变,但Dictionary实现不支持这一点.
当前的.NET字典实现是否被打破,因为它错误地忽略了哈希码限额？应该GetHashCode()只基于不可变成员？或者,还有什么可以打破可能的错误二分法吗？
class Hashable
{
public int PK { get; set; }
public override int GetHashCode()
{
if (PK != 0) return PK.GetHashCode();
return base.GetHashCode();
}
public override bool Equals(object obj)
{
return Equals(obj as Hashable);
}
public virtual bool Equals(Hashable other)
{
if (other == null) return false;
else if (ReferenceEquals(this, other)) return true;
else if (PK != 0 && other.PK != 0) return …Object.hashCode()的默认行为是返回对象的"地址",以便当且仅当a == b时,a.hashCode()== b.hashCode().如果超类已经定义了hashCode(),我如何在用户定义的类中获得此行为？例如:
class A {
public int hashCode() {
return 0;
}
}
class B extends A {
public int hashCode() {
// Now I want to return a unique hashcode for each object.
// In pythonic terms, it'd look something like:
return Object.hashCode(this);
}
}
想法？
基本上,GethashCode是不同的,即使它们包含属性的SAME值...那么为什么默认返回diff hashcodes？
public class User
{
public Int32 Id { get; set; }
public String Username { get; set; }
}
User a = new User();
a.Id = 1;
a.Username = "Hello";
User b = new User();
b.Id = 1;
b.Username = "Hello";
Console.WriteLine("Hash A: {0} | Hash B: {1}", a.GetHashCode(), b.GetHashCode());
//Hash A: 37121646 | Hash B: 45592480 <-- these values change each time I rerun the app?
有没有更合适的方法来实现它,所以我不会破坏Object.Equals如何为我的对象工作,但我仍然可以根据参数值进行自己的相等检查？
我问的原因是因为我有一个服务:SynchronizeUsers()下载一组用户.我宁愿只更新需要更新的那些,删除同步所说的那些,而不是清除我的用户缓存,而是添加新的.但是,我不能只对这些对象做Object.Equals().
用Java编写的现有系统使用字符串的哈希码作为其负载平衡的路由策略.
现在,我无法修改系统,但需要生成共享相同哈希码的字符串以测试最差条件.
我从命令行提供这些字符串,并希望系统将所有这些字符串路由到同一目的地.
是否可以生成共享相同哈希码的大量字符串？
要明确这个问题:
String[] getStringsInSameHashCode(int number){
//return an array in length "number"
//Every element of the array share the same hashcode.
//The element should be different from each other
}
备注:任何hashCode值都可以接受.字符串是什么没有约束.但它们应该彼此不同.
编辑:String类的重写方法是不可接受的,因为我从命令行提供这些字符串.
仪表也是不可接受的,因为这会对系统产生一些影响.
我正在寻找具有以下属性的Perl字符串校验和函数:
$string)$hash),0 <= $hash <= 2^32-1保持(0到4294967295,匹配4字节MySQL unsigned int的大小)伪代码:
sub checksum {
my $string = shift;
my $hash;
... checksum logic goes here ...
die unless ($hash >= 0);
die unless ($hash <= 4_294_967_295);
return $hash;
}
理想情况下,校验和函数应该快速运行,并且应该在目标空间(0.. 2^32-1)中稍微均匀地生成值以避免冲突.在这个应用程序中随机碰撞是完全非致命的,但显然我想在可能的范围内避免它们.
鉴于这些要求,解决这个问题的最佳方法是什么？
我正在使用hibernate并需要覆盖equals和hashCode().我选择使用google-guava的equals和hashCode助手.
我想知道我在这里是否遗漏了什么.
我有id/image和filePath的 get/set方法.
@Entity
@Table(name = "IMAGE")
public class ImageEntity {
private Integer idImage;
private String filePath;
@Override
public int hashCode() {
return Objects.hashCode(getFilePath());
}
@Override
public boolean equals(final Object obj) {
if(obj == this) return true;
if(obj == null) return false;
if(obj instanceof ImageEntity){
final ImageEntity otherImage = (ImageEntity) obj;
return Objects.equal(getFilePath(), otherImage.getFilePath());
}
return false;
}
}
编辑:
进入继承并在这里有一个样本
所以我对hashcode()和equals()方法有疑问
假设我只是写了一个非常基本的程序来覆盖这两个方法
import java.util.*;
class Employee
{
private String name;
private int empid;
public Employee(String name,int empid)
{
this.name=name;
this.empid=empid;
}
public int getEmpid()
{
return empid;
}
public String getName()
{
return name;
}
public boolean equals(Object obj)
{
System.out.println("equals has just been called...");
Employee e1=(Employee)obj;
return ((name.equals(e1.name)) && (empid==e1.empid));
}
public int hashCode()
{
System.out.println("hashcode called...");
return empid;
}
}
然后,假设我编写了另一个类来添加和迭代HashSet中的元素
class Five
{
public static void main(String args[])
{
HashSet hs1=new HashSet();
hs1.add(new Employee("Alex",25));
hs1.add(new Employee("Peter",25));
hs1.add(new …我在基于java的系统中工作,我需要为可视显示中的某些元素设置id.一类元素是字符串,所以我决定使用String.hashCode()方法来获取这些元素的唯一标识符.
然而,我遇到的问题是,如果id是负数并且String.hashCode经常返回负值,我在borks工作的系统.一个快速的解决方案是在hashcode调用周围使用Math.abs()来保证肯定的结果.我对这种方法感到疑惑的是,两个不同元素具有相同哈希码的可能性是多少？
例如,如果一个字符串返回的哈希码为-10,另一个字符串返回的哈希码为10,则会发生错误.在我的系统中,我们讨论的是通常不超过30个元素的对象集合,所以我不认为这确实是一个问题,但我很好奇数学所说的.
我非常喜欢Java 7+写作hashCode()方式:
@Override
public int hashCode() {
Objects.hash(field1, field2);
}
但它无法正常使用数组.以下代码:
@Override
public int hashCode() {
Objects.hash(field1, field2, array1, array2);
}
将不会工作,因为array1和array2常规hashCode()而不是Arrays.hashCode()被调用.
如何Objects.hash()以正确的方式使用数组？