JAVAHashSet和TreeSet实现保证存入元素不会重复

static final long serialVersiOnUID= -5024744406713321676L;
 
  private transient HashMap 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 HashMap 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 strSet = new HashSet();
 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 objSet = new HashSet();
 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) &＃63; 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

 /**
   * The backing map.
   */
  private transient NavigableMap 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 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 mutually
   * comparable: {@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()); // 将一个新生成的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 t = root; // 定义t为根节点
    if (t == null) { // 如果根节点为空
      compare(key, key); // type (and possibly null) check // 对自身做对比，如果有对比器就用对比器的规则进行对比，如果没有，就用元素自身对比的规则进行对比。为0则相等。我觉得这波其实没有意义，就是一个空的对比。
 
      root = new Entry<>(key, value, null); // 新建一个空的根节点
      size = 1; // 设置大小为1
      modCount++; //对0做+1
      return null; // 返回空值，表示插入成功。
    }
    int cmp;
    Entry parent;
    // split comparator and comparable paths
    Comparator<&＃63; 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<&＃63; super K> k = (Comparable<&＃63; super K>) key;// 生成可比较的对象Comparable
      do {
        parent = t; 将父节点（最初是根节点）赋值给parent
        cmp = k.compareTo(t.key); //对我们要插入的key与根节点的keyj进行对比
        if (cmp <0) // 对比后值小于0，则表示我们插入的key小于根节点的key，就让父节点往左走，并循环直至命中
          t = t.left;
        else if (cmp > 0) // 对比后值大于0，则表示我们插入的key小于根节点的key，就让父节点往右走，并循环直至命中
          t = t.right;
        else //当命中，用我们的值替换原有的值一次保证不插入重复的key，并返回替换后的对象
          return t.setValue(value);
      } while (t != null);
    }
    Entry e = new Entry<>(key, value, parent); // 如果没有在树中命中，则新生成一个树节点此时parent的父节点已经遍历到了某个叶子节点。
    if (cmp <0) // 如果你的这个值是小于叶子节点的，则插入左边，大于则插入右边
      parent.left = e;
    else
      parent.right = e;
    fixAfterInsertion(e); // 对整棵树做平衡修正
    size++; // size值加1表示我们插入了一个值
    modCount++; // modCount也加1
    return null;
  }