Este puede no ser el escenario del mundo real, pero solo curiosidad por saber qué sucede, a continuación se muestra el código.

Estoy creando un conjunto de objetos de clase.UsingSet. De acuerdo con el concepto de hashing en Java, cuando agrego un objeto que contiene "a", creará un cubo con hashcode 97 y colocará el objeto dentro de él. Nuevamente, cuando encuentra un objeto con "a", llamará al método de código hash anulado en la clase UsingSet y obtendrá el código hash 97, entonces, ¿qué sigue?

Como no he anulado el método igual, la implementación predeterminada devolverá falso. Entonces, ¿dónde se mantendrá el Objeto con el valor "a", en el mismo depósito donde se mantuvo el objeto anterior con el código hash 97? o creará un nuevo cubo? Alguien sabe cómo se almacenará internamente?

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

class UsingSet {  

  String value;  

  public UsingSet(String value){  
    this.value = value;  
  }  

  public String toString() {  
    return value;  
  }  

  public int hashCode() {  
    int hash = value.hashCode();  
    System.out.println("hashcode called" + hash);  
    return hash;  
  }  

  public static void main(String args[]) {  

    java.util.Set s = new java.util.HashSet();  

    s.add(new UsingSet("A"));  
    s.add(new UsingSet("b"));  
    s.add(new UsingSet("a"));  
    s.add(new UsingSet("b"));   
    s.add(new UsingSet("a"));  

    s.add(new Integer(1));  
    s.add(new Integer(1));  

    System.out.println("s = " + s); 

  }  
}  

la salida es:

hashcode called65
hashcode called98
hashcode called97
hashcode called98
hashcode called97
s = [1, b, b, A, a, a]