如何排查未重写hashCode()且被哈希使用的类以提升程序确定性？

Great question! When you're trying to make your Java program more deterministic, rooting out classes that rely on Object's default hashCode() (tied to memory addresses and variable between runs) for HashMap/HashSet operations is critical. Here are practical, actionable ways to track these down:

1. Static Code Analysis Tools (Quick & Low-Effort) #

These tools scan your codebase without running it, making them perfect for early detection:

• SpotBugs/FindBugs: Look for the EQ_DOESNT_OVERRIDE_EQUALS rule (flags classes that override equals() but not hashCode()) and custom rules that specifically check for classes used as hash collection keys without a custom hashCode(). Most IDEs have plugins that integrate these checks directly into your workflow.
• IntelliJ IDEA/Android Studio: Enable the Equals and HashCode inspection under Settings > Editor > Inspections > Java > Object equality. It will highlight instances where a class is used as a HashMap key or HashSet element but doesn't override hashCode().
• SonarQube: Its rule set includes checks for inconsistent equals()/hashCode() implementations and classes used in hash-based collections without proper hashCode() overrides. Run a Sonar scan on your project and filter results for these issues.

2. Runtime Detection (Catch Edge Cases) #

If static analysis misses dynamic or runtime-only uses, try these approaches:

• Custom Wrapper Classes: Create a temporary wrapper around HashMap or HashSet that checks the key/element's hashCode() origin before allowing operations. For example:

  public class HashTrackingSet<E> extends HashSet<E> {
      @Override
      public boolean add(E e) {
          checkDefaultHashCode(e);
          return super.add(e);
      }
  
      private void checkDefaultHashCode(Object obj) {
          if (obj == null) return;
          try {
              Method hashCodeMethod = obj.getClass().getMethod("hashCode");
              if (hashCodeMethod.getDeclaringClass() == Object.class) {
                  System.out.printf("Warning: Class %s uses default hashCode() in HashSet%n", obj.getClass().getName());
                  // Log to a file or collect these classes for later review
              }
          } catch (NoSuchMethodException ignored) { /* Impossible, since all objects have hashCode() */ }
      }
  }
  

  Swap out your regular HashSet instances with this wrapper during testing runs—any class relying on the default hashCode() will trigger a warning.
• Java Agent or AspectJ: Use bytecode manipulation to intercept calls to HashMap.put(), HashSet.add(), etc. A Java Agent can rewrite these methods to add a check: whenever a key is added, verify if its class inherits hashCode() directly from Object. AspectJ can create a cross-cutting aspect that applies this check across your entire codebase without modifying existing classes.

3. Bytecode Analysis (Deep Dive) #

For complex codebases with heavy reflection or dynamic class loading, use bytecode parsing libraries like ASM or Byte Buddy:

• Scan all class files in your project to identify methods that interact with HashMap/HashSet.
• Extract the actual types used as keys/elements (bypassing generics erasure).
• For each identified type, check if it overrides hashCode() by examining its bytecode methods.

Key Notes to Keep in Mind #

• Don't forget to check nested classes, anonymous inner classes, and even third-party classes you're using as keys—these are often overlooked sources of non-determinism.
• Remember that a class should always override both equals() and hashCode() if it's used in hash collections—violating this contract can lead to unexpected behavior beyond just non-determinism.

内容的提问来源于stack exchange，提问作者Bogdan