Please do not top-post - it makes it harder to understand to what you are
responding.

/What/ is really not the case?  That you need to override equals()?  But you
most certainly do need to.

Again, it's "Hashtable", not "HashTable".

Thus guaranteeing that the inserted objects do not == objects in another Set.

Because you did not override equals(), as has been repeatedly explained.

My advice is to follow the advice you've already been given.

From: Patricia Shanahan <pats@acm.org>

...

I'm afraid I don't really understand this remark, because you also say
"even for custom3 objects with exactly the same fields" which also
strongly suggest that two distinct custom3 instances can be equal,
exactly the situation I was talking about.

...

I'm afraid the only advice that will work is essentially the advice
everyone has been giving you.

You need to look VERY closely at the equals implementation for custom3.

First temporarily take hashCode out of the picture by implementing it in
each customN class as follows:

public int hashCode(){
  return 0;
}

That will make HashSet inefficient, but make it impossible for hashCode
bugs to prevent correct HashSet operation. When everything is working
functionally you should implement a good hashCode for each class,
matching its equals method.

You need to work through each of your classes, implementing AND TESTING
equals. Make sure you test equals with parameter type Object, not
custom3 etc.

I would begin with custom2, because it seems to be bottom of the
dependency hierarchy. Can two custom2 objects be equal because they have
equal fields, without being the same object? If so, write an equals
method that tests whether they have the same fields.

At each step, make sure you have a overridden hashCode with the trivial
version, and that you have tested equals and are happy with the results.

Once custom3's equals method returns true exactly when you think the two
objects are equal, your HashSet containsKey test will work just fine.

If this advice does not solve your problem, I suggest an SSCCE:
http://www.physci.org/codes/sscce/

Patricia

Here's a different approach to explaining what I think is going on. I've
written two trivial classes, NoEquals and HasEquals. Each has two String
fields. The difference is that NoEquals inherits equals and hashCode
from Object. HasEquals has a trivial, dummy hashCode and an equals that
treats HasEquals instances with equal fields as being equal.

I also wrote a test method that takes a pair of references and does some
tests of the sorts of things that I gather, from your messages, are
going on in your program, constructing a Set of instances of the class
and using it as a Map key. It is called three times, with a pair of
NoEquals objects, with an equal pair of HasEquals objects, and with an
unequal pair of HasEquals objects.

The test demonstrates how the results of the Set contains and Map
containsKey methods depend on the underlying equals implementation in my
classes. If this program does not explain what is going on in your
code, try to modify it to demonstrate the problem and post the result.

Output:

NoEquals objects
left == right is false
left.equals(right) is false
s1.contains(right) is false
m.containsKey(s1) is false

equal HasEquals objects
left == right is false
left.equals(right) is true
s1.contains(right) is true
m.containsKey(s1) is true

unequal HasEquals objects
left == right is false
left.equals(right) is false
s1.contains(right) is false
m.containsKey(s1) is false

Source code - copy to an EqualsDemo.java file:

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class EqualsDemo {

  static void test(Object left, Object right) {
    System.out.printf("left == right is %b%n", left == right);
    System.out.printf("left.equals(right) is %b%n", left
        .equals(right));
    Set<Object> s1 = new HashSet<Object>();
    s1.add(left);
    System.out.printf("s1.contains(right) is %b%n", s1
        .contains(right));
    Map<Object, String> m = new HashMap<Object, String>();
    m.put(s1, "Dummy string");
    Set<Object> s2 = new HashSet<Object>();
    s2.add(right);
    System.out.printf("m.containsKey(s1) is %b%n", m
        .containsKey(s2));
  }

  public static void main(String[] args) {
    System.out.println("NoEquals objects");
    test(new NoEquals("a", "b"), new NoEquals("a", "b"));
    System.out.println();
    System.out.println("equal HasEquals objects");
    test(new HasEquals("a", "b"), new HasEquals("a", "b"));
    System.out.println();
    System.out.println("unequal HasEquals objects");
    test(new HasEquals("a", "b"), new HasEquals("a", "B"));
  }
}

class NoEquals {
  String field1;
  String field2;
  NoEquals(String field1, String field2) {
    this.field1 = field1;
    this.field2 = field2;
  }
}

class HasEquals {
  String field1;
  String field2;
  HasEquals(String field1, String field2) {
    this.field1 = field1;
    this.field2 = field2;
  }
  public boolean equals(Object obj) {
    if (obj == null || !(obj instanceof HasEquals)) {
      return false;
    } else {
      HasEquals other = (HasEquals) obj;
      return field1.equals(other.field1)
          && field2.equals(other.field2);
    }
  }

  /*
   * Dummy hashCode for testing equals, do not use in production
   * code.
   */
  public int hashCode() {
    return 0;
  }
}