static final long serialVersionUID = -5024744406713321676L;
 
  private transient HashMap<E,Object> map;
 
  // Dummy value to associate with an Object in the backing Map
  private static final Object PRESENT = new Object();
 
  /**
   * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
   * default initial capacity (16) and load factor (0.75).
   */
  public HashSet() {
    map = new HashMap<>();
  }

 public boolean add(E e) {
    return map.put(e, PRESENT)==null;
  }

public class SetTest {
 
 public class Obj {
 public String name;
 public Obj(String name) {
  this.name=name;
 }
 }
 
 public static void main(String[] args) {
 Set<String> strSet = new HashSet<String>();
 String str1 = new String("123");
 String str2 = new String("123");
 strSet.add(str1);
 strSet.add(str2);
 System.out.println(str1 == str2);
 for(String str : strSet) {
  System.out.println(str);
 }
 Set<Obj> objSet = new HashSet<Obj>();
 Obj o1 = new SetTest().new Obj("1");
 Obj o2 = new SetTest().new Obj("1");
 objSet.add(o1);
 objSet.add(o2);
 for(Obj str : objSet) {
  System.out.println(str.name);
 } 
 } 
}

false
123
1
1

 public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
  }

 static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

 /**
   * The backing map.
   */
  private transient NavigableMap<E,Object> m;
 
  // Dummy value to associate with an Object in the backing Map
  private static final Object PRESENT = new Object();
 
  /**
   * Constructs a set backed by the specified navigable map.
   */
  TreeSet(NavigableMap<E,Object> m) {
    this.m = m;
  }
/**
   * Constructs a new, empty tree set, sorted according to the
   * natural ordering of its elements. All elements inserted into
   * the set must implement the {@link Comparable} interface.
   * Furthermore, all such elements must be <i>mutually
   * comparable</i>: {@code e1.compareTo(e2)} must not throw a
   * {@code ClassCastException} for any elements {@code e1} and
   * {@code e2} in the set. If the user attempts to add an element
   * to the set that violates this constraint (for example, the user
   * attempts to add a string element to a set whose elements are
   * integers), the {@code add} call will throw a
   * {@code ClassCastException}.
   */
  public TreeSet() {
    this(new TreeMap<E,Object>()); // 將一個新生成的TreeMap空對象賦值給m，也就是上一方法
  }

 public TreeMap() {
    comparator = null;
  }

public boolean add(E e) {
    return m.put(e, PRESENT)==null; // 如果返回值為空則表示我們插入了一個新的元素，如果返回值為非空，則表明我們插入的元素已經存在。
  }

 public V put(K key, V value) {
    Entry<K,V> t = root; // 定義t為根節(jié)點
    if (t == null) { // 如果根節(jié)點為空
      compare(key, key); // type (and possibly null) check // 對自身做對比，如果有對比器就用對比器的規(guī)則進行對比，如果沒有，就用元素自身對比的規(guī)則進行對比。為0則相等。我覺得這波其實沒有意義，就是一個空的對比。
 
      root = new Entry<>(key, value, null); // 新建一個空的根節(jié)點
      size = 1; // 設置大小為1
      modCount++; //對0做+1
      return null; // 返回空值，表示插入成功。
    }
    int cmp;
    Entry<K,V> parent;
    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator; // 用本treeMap的對比器對cpr賦值
    if (cpr != null) { // 如果定義的對比器不為空（在TreeSet里是為空的，我們之間說到過）
      do {
        parent = t; 
        cmp = cpr.compare(key, t.key);
        if (cmp < 0)
          t = t.left;
        else if (cmp > 0)
          t = t.right;
        else
          return t.setValue(value);
      } while (t != null);
    }
    else { // 如果對比器為空（在這種情況下是為空的）
      if (key == null) // 如果key為空就拋出錯誤
        throw new NullPointerException();
      @SuppressWarnings("unchecked")
      Comparable<? super K> k = (Comparable<? super K>) key;// 生成可比較的對象Comparable
      do {
        parent = t; 將父節(jié)點（最初是根節(jié)點）賦值給parent
        cmp = k.compareTo(t.key); //對我們要插入的key與根節(jié)點的keyj進行對比
        if (cmp < 0) // 對比后值小于0，則表示我們插入的key小于根節(jié)點的key，就讓父節(jié)點往左走，并循環(huán)直至命中
          t = t.left;
        else if (cmp > 0) // 對比后值大于0，則表示我們插入的key小于根節(jié)點的key，就讓父節(jié)點往右走，并循環(huán)直至命中
          t = t.right;
        else //當命中，用我們的值替換原有的值一次保證不插入重復的key，并返回替換后的對象
          return t.setValue(value);
      } while (t != null);
    }
    Entry<K,V> e = new Entry<>(key, value, parent); // 如果沒有在樹中命中，則新生成一個樹節(jié)點此時parent的父節(jié)點已經遍歷到了某個葉子節(jié)點。
    if (cmp < 0) // 如果你的這個值是小于葉子節(jié)點的，則插入左邊，大于則插入右邊
      parent.left = e;
    else
      parent.right = e;
    fixAfterInsertion(e); // 對整棵樹做平衡修正
    size++; // size值加1表示我們插入了一個值
    modCount++; // modCount也加1
    return null;
  }