EnumerableObject : IEnumerable<Foo>
包裹一个 List<Foo>
如果EnumerableObject a.SequenceEquals( EnumerableObject b),那么他们是平等的.
因此,GetHashCode必须实施.问题是XORing列表中的每个元素将返回任何列表的相同哈希码,所有列表都包含所有且只有相同的元素,而不管顺序如何.就工作而言,这是好的,但会导致许多冲突,这将减慢检索速度等.
GetHashCode对于依赖于顺序的对象列表,什么是一种好的,快速的方法？
在Java中,我有一个表示带有int坐标的点的类
public class Point {
int x = -1;
int y = -1;
public Point (int xNew, int yNew) {
x = xNew; y = yNew;
}
public boolean equals (Object o) {
// no need for (o instanceof Point) by design
return x == ((Point)o).x && y == ((Point)o).y;
}
}
我正在使用类的对象Point作为a中的键HashMap和作为元素HashSet.
什么是该hashCode功能的最佳候选人？我会把它加倍,这样左边的部分是x而右边的部分是y,例如:
x = 4, y = 12,然后hashCode返回4.12.但是通过实现,它不能是double,只能是int.
这不是一个选择:
public int hashCode() {
// no …我一直在调查hashCode()java中的方法,并发现String类奇怪的一个.源代码如下:
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
代码本身非常简单.但我想知道以这种方式计算哈希码的原因是什么？
为什么选择31？
为什么从0开始而不是value.length - 1？
是否保证这会使哈希码更不可能相互冲突？
好吧,我从许多地方和消息来源得知,每当我覆盖equals()方法时,我都需要覆盖hashCode()方法.但请考虑以下代码
package test;
public class MyCustomObject {
int intVal1;
int intVal2;
public MyCustomObject(int val1, int val2){
intVal1 = val1;
intVal2 = val2;
}
public boolean equals(Object obj){
return (((MyCustomObject)obj).intVal1 == this.intVal1) &&
(((MyCustomObject)obj).intVal2 == this.intVal2);
}
public static void main(String a[]){
MyCustomObject m1 = new MyCustomObject(3,5);
MyCustomObject m2 = new MyCustomObject(3,5);
MyCustomObject m3 = new MyCustomObject(4,5);
System.out.println(m1.equals(m2));
System.out.println(m1.equals(m3));
}
}
这里输出是真的,完全按照我想要的方式错误,我根本不关心覆盖hashCode()方法.这意味着hashCode()覆盖是一个选项而不是每个人都说的强制选项.
我想要第二次确认.
在Scala中实现equals和hashCode方法的标准习惯是什么？
我知道在Scala编程中讨论了首选方法,但我目前无法访问该书.
为什么String.hashcode()有这么多冲突？
我在jdk1.6中读取String.hashCode(),下面是代码
public int hashCode() {
int h = hash;
if (h == 0) {
int off = offset;
char val[] = value;
int len = count;
for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;
}
return h;
}
这对我来说很混乱,因为它有很多冲突; 虽然它不需要是唯一的(我们仍然可以依赖于equals()),但是更少的冲突意味着更好的性能而无需访问链表中的条目.
假设我们有两个字符,那么只要我们找到两个匹配下面的方程的字符串,那么我们就会有相同的hashcode()
a * 31 +b = c * 31 +d
很容易得出结论,(a-c) * 31 = d-b
一个简单的例子是make ac = 1和db = 31; 所以我写下面的代码进行简单的测试
public void testHash() {
System.out.println("A:" …最近,在一次采访中我被问到,hashmap中究竟是什么？无论是数组还是arraylist还是什么？
我很困惑.我知道哈希映射是由数组支持的.那么我可以说bucket是一个容量为16的数组,在开始存储哈希码时,链接列表的起始指针是什么？
我知道hashmap内部是如何工作的,只是想知道数据结构方面究竟是什么样的桶.
如何使用@EqualsAndHashCodeWith Include，用于 Java 的 Lombok 库。
@EqualsAndHashCode.Include( )
如何让 Equals 比较类 ID？
例子：
@EqualsAndHashCode.Include( )
@Table(name = "USER")
public class User
{
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "IDENTITY_USER")
private Long identity;
}
许多书籍和教程都说哈希表的大小必须是在所有桶中均匀分配密钥的主要原因.但Java HashMap总是使用两个幂的大小.不应该使用素数吗？哈希表大小更好,"素数"或"两个幂"？
我们假设我上课了User:
public class User {
private Long id;
private String name;
private Integer age;
private BigDecimal account;
// other fields, getters and setters
}
equals如下覆盖方法是否合适？
@Override
public boolean equals(Object ob) {
if (ob == null) {
return false;
}
if (this == ob) {
return true;
}
if (ob instanceof User) {
User other = (User) ob;
return this.id.equals(other.getId());
}
return false;
}
事实证明,对象的唯一性仅由其ID确定.但在我的应用程序中,id总是独一无二的.它在数据库中提供.我的equals实施是否足以说明这一点？或者这不是最佳做法？
当然我理解在这种情况下,hashCode实现应该如下:
@Override
public int hashCode() {
return …