3 and 97 are prime numbers. Prime numbers are used to improve the spread of the hashcode. As for the equals method: The NetBeans method to handle doubles is superior as it properly deals with all kinds of doubles, including NaN and alike. The intelij and eclipse methods for equals provide a similar byte code pattern as each && is similar to a test and a jump. The quality of all approaches is the same, so no worries. What you like better is a matter of taste. If you want to know how Objects.hash does it, click on that method and invoke show source. You might see that method does something similar with prime numbers. It is a classic approach.
met vriendelijke groet Pieter van den Hombergh Op wo 5 nov 2025, 22:20 schreef Kenneth Fogel <[email protected]>: > For a discussion for Java Beans in my writing, I generated the hashCode > and equals methods in NetBeans. I then generated the same methods with > Eclipse and Intellij. It is the hashCode and equals methods that stood out > as Eclipse and Intellij generate the exact same code that is quite > different from NetBeans. > > NetBeans: > @Override > public int hashCode() { > int hash = 3; > hash = 97 * hash + Objects.hashCode(this.title); > hash = 97 * hash + Objects.hashCode(this.author); > hash = 97 * hash + Objects.hashCode(this.publisher); > hash = 97 * hash + Objects.hashCode(this.isbn); > hash = 97 * hash + this.pages; > hash = 97 * hash + this.copiesInStock; > hash = 97 * hash + this.copiesSold; > hash = 97 * hash + (int) > (Double.doubleToLongBits(this.wholesaleCost) ^ > (Double.doubleToLongBits(this.wholesaleCost) >>> 32)); > hash = 97 * hash + (int) > (Double.doubleToLongBits(this.retailPrice) ^ > (Double.doubleToLongBits(this.retailPrice) >>> 32)); > hash = 97 * hash + (this.suitableForChildren ? 1 : 0); > return hash; > } > > Eclipse and IntelliJ: > @Override > public int hashCode() { > return Objects.hash(title, author, publisher, isbn, pages, > copiesInStock, copiesSold, wholesaleCost, retailPrice, suitableForChildren); > } > > In NetBeans, why is the initial hash value 3 and then 97 that is always > added? Is the fact that 97 + 3 = 100 significant? From the perspective of > explaining what this code does, the Eclipse/IntelliJ version is much > simpler to describe. > > Is there a reason for the additional code in the NetBeans version. Is the > NetBeans version less prone to false positives, meaning you need to use > equals() less often? > > For the equals() method the difference is also interesting. > > NetBeans > @Override > public boolean equals(Object obj) { > if (this == obj) { > return true; > } > if (obj == null) { > return false; > } > if (getClass() != obj.getClass()) { > return false; > } > final BookBean other = (BookBean) obj; > if (this.pages != other.pages) { > return false; > } > if (this.copiesInStock != other.copiesInStock) { > return false; > } > if (this.copiesSold != other.copiesSold) { > return false; > } > if (Double.doubleToLongBits(this.wholesaleCost) != > Double.doubleToLongBits(other.wholesaleCost)) { > return false; > } > if (Double.doubleToLongBits(this.retailPrice) != > Double.doubleToLongBits(other.retailPrice)) { > return false; > } > if (this.suitableForChildren != other.suitableForChildren) { > return false; > } > if (!Objects.equals(this.title, other.title)) { > return false; > } > if (!Objects.equals(this.author, other.author)) { > return false; > } > if (!Objects.equals(this.publisher, other.publisher)) { > return false; > } > return Objects.equals(this.isbn, other.isbn); > } > > Eclipse and IntelliJ > @Override > public boolean equals(Object o) { > if (o == null || getClass() != o.getClass()) return false; > BookBean bookBean = (BookBean) o; > return pages == bookBean.pages && copiesInStock == > bookBean.copiesInStock && copiesSold == bookBean.copiesSold && > Double.compare(wholesaleCost, bookBean.wholesaleCost) == 0 && > Double.compare(retailPrice, bookBean.retailPrice) == 0 && > suitableForChildren == bookBean.suitableForChildren && > Objects.equals(title, bookBean.title) && Objects.equals(author, > bookBean.author) && Objects.equals(publisher, bookBean.publisher) && > Objects.equals(isbn, bookBean.isbn); > } > > In this code Eclipse and IntelliJ use Double.compare for comparing fields > that are doubles while NetBeans uses Double.doubleToLongBits. > > Is this even something to worry about? I am not advocating for this code > to be the same in all three IDEs. I would like to know if the differences > are significant. From what I see and from my limited understanding about > how this code performs, I’d guess the IntelliJ/Eclipse code is superior. > > Ken > > > > > >
